ar_sync 1.0.0

data/core/ArSyncModelBase.js

@@ -0,0 +1,110 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class ArSyncModelBase {
+    constructor(request, option) {
+        this._ref = this.refManagerClass().retrieveRef(request, option);
+        this._listenerSerial = 0;
+        this._listeners = {};
+        this.complete = false;
+        this.connected = this.connectionManager().networkStatus;
+        const setData = () => {
+            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;
+        });
+    }
+    onload(callback) {
+        this.subscribeOnce('load', callback);
+    }
+    subscribeOnce(event, callback) {
+        const subscription = this.subscribe(event, (arg) => {
+            callback(arg);
+            subscription.unsubscribe();
+        });
+        return subscription;
+    }
+    subscribe(event, callback) {
+        const id = this._listenerSerial++;
+        const subscription = this._ref.model.subscribe(event, callback);
+        let unsubscribed = false;
+        const unsubscribe = () => {
+            unsubscribed = true;
+            subscription.unsubscribe();
+            delete this._listeners[id];
+        };
+        if (this.complete) {
+            if (event === 'load')
+                setTimeout(() => {
+                    if (!unsubscribed)
+                        callback();
+                }, 0);
+            if (event === 'change')
+                setTimeout(() => {
+                    if (!unsubscribed)
+                        callback({ path: [], value: this.data });
+                }, 0);
+        }
+        return this._listeners[id] = { unsubscribe };
+    }
+    release() {
+        for (const id in this._listeners)
+            this._listeners[id].unsubscribe();
+        this._listeners = {};
+        this.refManagerClass()._detach(this._ref);
+        this._ref = null;
+    }
+    static retrieveRef(request, option) {
+        const key = JSON.stringify([request, option]);
+        let ref = this._cache[key];
+        if (!ref) {
+            const model = this.createRefModel(request, option);
+            ref = this._cache[key] = { key, count: 0, timer: null, model };
+        }
+        this._attach(ref);
+        return ref;
+    }
+    static createRefModel(_request, _option) {
+        throw 'abstract method';
+    }
+    static _detach(ref) {
+        ref.count--;
+        const timeout = this.cacheTimeout;
+        if (ref.count !== 0)
+            return;
+        const timedout = () => {
+            ref.model.release();
+            delete this._cache[ref.key];
+        };
+        if (timeout) {
+            ref.timer = setTimeout(timedout, timeout);
+        }
+        else {
+            timedout();
+        }
+    }
+    static _attach(ref) {
+        ref.count++;
+        if (ref.timer)
+            clearTimeout(ref.timer);
+    }
+    static setConnectionAdapter(_adapter) { }
+    static waitForLoad(...models) {
+        return new Promise((resolve) => {
+            let count = 0;
+            for (const model of models) {
+                model.onload(() => {
+                    count++;
+                    if (models.length == count)
+                        resolve(models);
+                });
+            }
+        });
+    }
+}
+exports.default = ArSyncModelBase;

data/core/ConnectionAdapter.d.ts

@@ -0,0 +1,7 @@
+export default interface ConnectionAdapter {
+    ondisconnect: (() => void) | null;
+    onreconnect: (() => void) | null;
+    subscribe(key: string, callback: (data: any) => void): {
+        unsubscribe: () => void;
+    };
+}

data/core/ConnectionAdapter.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

data/core/ConnectionManager.d.ts

@@ -0,0 +1,19 @@
+export default class ConnectionManager {
+    subscriptions: any;
+    adapter: any;
+    networkListeners: any;
+    networkListenerSerial: any;
+    networkStatus: any;
+    constructor(adapter: any);
+    triggerNetworkChange(status: any): void;
+    unsubscribeAll(): void;
+    subscribeNetwork(func: any): {
+        unsubscribe: () => void;
+    };
+    subscribe(key: any, func: any): {
+        unsubscribe: () => void;
+    };
+    connect(key: any): any;
+    disconnect(key: any): void;
+    received(key: any, data: any): void;
+}

data/core/ConnectionManager.js

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

data/core/DataType.d.ts

@@ -0,0 +1,60 @@
+declare type RecordType = {
+    _meta?: {
+        query: any;
+    };
+};
+declare type Values<T> = T extends {
+    [K in keyof T]: infer U;
+} ? U : never;
+declare type DataTypeExtractField<BaseType, Key extends keyof BaseType> = BaseType[Key] extends RecordType ? (null extends BaseType[Key] ? {} | null : {}) : BaseType[Key] extends RecordType[] ? {}[] : BaseType[Key];
+declare type DataTypeExtractFieldsFromQuery<BaseType, Fields> = '*' extends Fields ? {
+    [key in Exclude<keyof BaseType, '_meta'>]: DataTypeExtractField<BaseType, key>;
+} : {
+    [key in Fields & keyof (BaseType)]: DataTypeExtractField<BaseType, key>;
+};
+interface ExtraFieldErrorType {
+    error: 'extraFieldError';
+}
+declare type DataTypeExtractFromQueryHash<BaseType, QueryType> = '*' extends keyof QueryType ? {
+    [key in Exclude<(keyof BaseType) | (keyof QueryType), '_meta' | '_params' | '*'>]: (key extends keyof BaseType ? (key extends keyof QueryType ? (QueryType[key] extends true ? DataTypeExtractField<BaseType, key> : DataTypeFromQuery<BaseType[key] & {}, QueryType[key]>) : DataTypeExtractField<BaseType, key>) : ExtraFieldErrorType);
+} : {
+    [key in keyof QueryType]: (key extends keyof BaseType ? (QueryType[key] extends true ? DataTypeExtractField<BaseType, key> : DataTypeFromQuery<BaseType[key] & {}, QueryType[key]>) : ExtraFieldErrorType);
+};
+declare type _DataTypeFromQuery<BaseType, QueryType> = QueryType extends keyof BaseType | '*' ? DataTypeExtractFieldsFromQuery<BaseType, QueryType> : QueryType extends Readonly<(keyof BaseType | '*')[]> ? DataTypeExtractFieldsFromQuery<BaseType, Values<QueryType>> : QueryType extends {
+    as: string;
+} ? {
+    error: 'type for alias field is not supported';
+} | undefined : DataTypeExtractFromQueryHash<BaseType, QueryType>;
+export declare type DataTypeFromQuery<BaseType, QueryType> = BaseType extends any[] ? CheckAttributesField<BaseType[0], QueryType>[] : null extends BaseType ? CheckAttributesField<BaseType & {}, QueryType> | null : CheckAttributesField<BaseType & {}, QueryType>;
+declare type CheckAttributesField<P, Q> = Q extends {
+    attributes: infer R;
+} ? _DataTypeFromQuery<P, R> : _DataTypeFromQuery<P, Q>;
+declare type IsAnyCompareLeftType = {
+    __any: never;
+};
+declare type CollectExtraFields<Type, Path> = IsAnyCompareLeftType extends Type ? null : Type extends ExtraFieldErrorType ? Path : Type extends (infer R)[] ? _CollectExtraFields<R> : Type extends object ? _CollectExtraFields<Type> : null;
+declare type _CollectExtraFields<Type> = keyof (Type) extends never ? null : Values<{
+    [key in keyof Type]: CollectExtraFields<Type[key], [key]>;
+}>;
+declare type SelectString<T> = T extends string ? T : never;
+declare type _ValidateDataTypeExtraFileds<Extra, Type> = SelectString<Values<Extra>> extends never ? Type : {
+    error: {
+        extraFields: SelectString<Values<Extra>>;
+    };
+};
+declare type ValidateDataTypeExtraFileds<Type> = _ValidateDataTypeExtraFileds<CollectExtraFields<Type, []>, Type>;
+declare type RequestBase = {
+    api: string;
+    query: any;
+    params?: any;
+    _meta?: {
+        data: any;
+    };
+};
+declare type DataTypeBaseFromRequestType<R> = R extends {
+    _meta?: {
+        data: infer DataType;
+    };
+} ? DataType : never;
+export declare type DataTypeFromRequest<Req extends RequestBase, R extends RequestBase> = ValidateDataTypeExtraFileds<DataTypeFromQuery<DataTypeBaseFromRequestType<Req>, R['query']>>;
+export {};

data/core/DataType.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

data/core/hooksBase.d.ts

@@ -0,0 +1,29 @@
+interface ModelStatus {
+    complete: boolean;
+    notfound?: boolean;
+    connected: boolean;
+}
+export declare type DataAndStatus<T> = [T | null, ModelStatus];
+export interface Request {
+    api: string;
+    params?: any;
+    query: any;
+}
+interface ArSyncModel<T> {
+    data: T | null;
+    complete: boolean;
+    connected: boolean;
+    notfound?: boolean;
+    release(): void;
+    subscribe(type: any, callback: any): any;
+}
+export declare function useArSyncModelWithClass<T>(modelClass: {
+    new <T>(req: Request, option?: any): ArSyncModel<T>;
+}, request: Request | null): DataAndStatus<T>;
+interface FetchStatus {
+    complete: boolean;
+    notfound?: boolean;
+}
+declare type DataAndStatusAndUpdater<T> = [T | null, FetchStatus, () => void];
+export declare function useArSyncFetch<T>(request: Request | null): DataAndStatusAndUpdater<T>;
+export {};

data/core/hooksBase.js

@@ -0,0 +1,80 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const react_1 = require("react");
+const ArSyncApi_1 = require("./ArSyncApi");
+function useArSyncModelWithClass(modelClass, request) {
+    const [data, setData] = react_1.useState(null);
+    const [status, setStatus] = react_1.useState({ complete: false, connected: true });
+    const updateStatus = (complete, notfound, connected) => {
+        if (complete === status.complete || notfound === status.notfound || connected === status.notfound)
+            return;
+        setStatus({ complete, notfound, connected });
+    };
+    react_1.useEffect(() => {
+        if (!request)
+            return () => { };
+        const model = new modelClass(request, { immutable: true });
+        if (model.complete)
+            setData(model.data);
+        updateStatus(model.complete, model.notfound, model.connected);
+        model.subscribe('change', () => {
+            updateStatus(model.complete, model.notfound, model.connected);
+            setData(model.data);
+        });
+        model.subscribe('connection', () => {
+            updateStatus(model.complete, model.notfound, model.connected);
+        });
+        return () => model.release();
+    }, [JSON.stringify(request && request.params)]);
+    return [data, status];
+}
+exports.useArSyncModelWithClass = useArSyncModelWithClass;
+function useArSyncFetch(request) {
+    const [response, setResponse] = react_1.useState(null);
+    const [status, setStatus] = react_1.useState({ complete: false });
+    const requestString = JSON.stringify(request && request.params);
+    let canceled = false;
+    let timer = null;
+    const update = react_1.useCallback(() => {
+        if (!request) {
+            setStatus({ complete: false, notfound: undefined });
+            return () => { };
+        }
+        canceled = false;
+        timer = null;
+        const fetch = (count) => {
+            if (timer)
+                clearTimeout(timer);
+            timer = null;
+            ArSyncApi_1.default.fetch(request)
+                .then((response) => {
+                if (canceled)
+                    return;
+                setResponse(response);
+                setStatus({ complete: true, notfound: false });
+            })
+                .catch(e => {
+                if (canceled)
+                    return;
+                if (!e.retry) {
+                    setResponse(null);
+                    setStatus({ complete: true, notfound: true });
+                    return;
+                }
+                timer = setTimeout(() => fetch(count + 1), 1000 * Math.min(4 ** count, 30));
+            });
+        };
+        fetch(0);
+    }, [requestString]);
+    react_1.useEffect(() => {
+        update();
+        return () => {
+            canceled = true;
+            if (timer)
+                clearTimeout(timer);
+            timer = null;
+        };
+    }, [requestString]);
+    return [response, status, update];
+}
+exports.useArSyncFetch = useArSyncFetch;

data/graph/ArSyncModel.d.ts

@@ -0,0 +1,10 @@
+import ArSyncModelBase from '../core/ArSyncModelBase';
+import ConnectionAdapter from '../core/ConnectionAdapter';
+export default class ArSyncModel<T> extends ArSyncModelBase<T> {
+    static setConnectionAdapter(adapter: ConnectionAdapter): void;
+    static createRefModel(request: any, option: any): any;
+    refManagerClass(): typeof ArSyncModel;
+    connectionManager(): any;
+    static _cache: {};
+    static cacheTimeout: number;
+}

data/graph/ArSyncModel.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const ArSyncStore_1 = require("./ArSyncStore");
+const ConnectionManager_1 = require("../core/ConnectionManager");
+const ArSyncModelBase_1 = require("../core/ArSyncModelBase");
+class ArSyncModel extends ArSyncModelBase_1.default {
+    static setConnectionAdapter(adapter) {
+        ArSyncStore_1.default.connectionManager = new ConnectionManager_1.default(adapter);
+    }
+    static createRefModel(request, option) {
+        return new ArSyncStore_1.default(request, option);
+    }
+    refManagerClass() {
+        return ArSyncModel;
+    }
+    connectionManager() {
+        return ArSyncStore_1.default.connectionManager;
+    }
+}
+ArSyncModel._cache = {};
+ArSyncModel.cacheTimeout = 10 * 1000;
+exports.default = ArSyncModel;

data/graph/ArSyncStore.d.ts

@@ -0,0 +1,28 @@
+export default class ArSyncStore {
+    immutable: any;
+    markedForFreezeObjects: any;
+    changes: any;
+    eventListeners: any;
+    markForRelease: any;
+    container: any;
+    request: any;
+    complete: boolean;
+    notfound?: boolean;
+    data: any;
+    changesBufferTimer: number | undefined | null;
+    retryLoadTimer: number | undefined | null;
+    static connectionManager: any;
+    constructor(request: any, { immutable }?: {
+        immutable?: boolean | undefined;
+    });
+    load(retryCount: number): void;
+    setChangesBufferTimer(): void;
+    subscribe(event: any, callback: any): {
+        unsubscribe: () => void;
+    };
+    trigger(event: any, arg?: any): void;
+    mark(object: any): void;
+    freezeRecursive(obj: any): any;
+    freezeMarked(): void;
+    release(): void;
+}