ar_sync 1.0.1 → 1.0.2

data/src/tree/hooks.ts

@@ -1,7 +0,0 @@
-export { useArSyncFetch } from '../core/hooksBase'
-import { useArSyncModelWithClass, Request, DataAndStatus } from '../core/hooksBase'
-import ArSyncModel from './ArSyncModel'
-
-export function useArSyncModel<T>(request: Request | null): DataAndStatus<T> {
-  return useArSyncModelWithClass<T>(ArSyncModel, request)
-}

data/src/tree/index.ts

@@ -1,2 +0,0 @@
-import ArSyncModel from './ArSyncModel'
-export default ArSyncModel

data/tree/ArSyncModel.d.ts

@@ -1,39 +0,0 @@
-import ArSyncModelBase from '../core/ArSyncModelBase';
-import ConnectionAdapter from '../core/ConnectionAdapter';
-declare class ArSyncRecord {
-    immutable: any;
-    request: any;
-    subscriptions: any;
-    store: any;
-    retryLoadTimer: any;
-    data: any;
-    bufferTimer: any;
-    bufferedPatches: any;
-    eventListeners: any;
-    networkSubscription: any;
-    complete: boolean;
-    notfound?: boolean;
-    static connectionManager: any;
-    constructor(request: any, option?: {
-        immutable?: boolean | undefined;
-    });
-    release(): void;
-    unsubscribeAll(): void;
-    load(callback: any, retryCount?: number): void;
-    retryLoad(callback: any, retryCount: any): void;
-    patchReceived(patch: any): void;
-    subscribe(event: any, callback: any): {
-        unsubscribe: () => void;
-    };
-    trigger(event: any, arg?: any): void;
-    initializeStore(keys: any, data: any, option: any): void;
-}
-export default class ArSyncModel<T> extends ArSyncModelBase<T> {
-    static setConnectionAdapter(adapter: ConnectionAdapter): void;
-    static createRefModel(request: any, option: any): ArSyncRecord;
-    refManagerClass(): typeof ArSyncModel;
-    connectionManager(): any;
-    static _cache: {};
-    static cacheTimeout: number;
-}
-export {};

data/tree/ArSyncModel.js

@@ -1,143 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const ArSyncStore_1 = require("./ArSyncStore");
-const ArSyncApi_1 = require("../core/ArSyncApi");
-const ConnectionManager_1 = require("../core/ConnectionManager");
-const ArSyncModelBase_1 = require("../core/ArSyncModelBase");
-class ArSyncRecord {
-    constructor(request, option = {}) {
-        this.immutable = option.immutable ? true : false;
-        this.request = request;
-        this.subscriptions = [];
-        this.store = null;
-        this.data = null;
-        this.complete = false;
-        this.bufferedPatches = [];
-        this.eventListeners = { events: {}, serial: 0 };
-        this.networkSubscription = ArSyncRecord.connectionManager.subscribeNetwork((status) => {
-            if (this.notfound) {
-                this.trigger('connection', status);
-                return;
-            }
-            if (status) {
-                this.load(() => {
-                    this.trigger('connection', status);
-                    this.trigger('change', { path: [], value: this.data });
-                });
-            }
-            else {
-                this.unsubscribeAll();
-                this.trigger('connection', false);
-            }
-        });
-        this.load(() => {
-            this.trigger('load');
-            this.trigger('change', { path: [], value: this.data });
-        });
-    }
-    release() {
-        this.unsubscribeAll();
-        this.networkSubscription.unsubscribe();
-    }
-    unsubscribeAll() {
-        if (this.retryLoadTimer)
-            clearTimeout(this.retryLoadTimer);
-        for (const s of this.subscriptions)
-            s.unsubscribe();
-        this.subscriptions = [];
-    }
-    load(callback, retryCount = 0) {
-        ArSyncApi_1.default.syncFetch(this.request).then(syncData => {
-            const { keys, data, limit, order } = syncData;
-            this.initializeStore(keys, data, { limit, order, immutable: this.immutable });
-            if (callback)
-                callback(true, this.data);
-        }).catch(e => {
-            console.error(e);
-            if (e.retry) {
-                this.retryLoad(callback, retryCount + 1);
-            }
-            else {
-                this.initializeStore(null, null, null);
-                if (callback)
-                    callback(false, this.data);
-            }
-        });
-    }
-    retryLoad(callback, retryCount) {
-        const sleepSeconds = Math.min(Math.pow(2, retryCount), 30);
-        this.retryLoadTimer = setTimeout(() => {
-            this.retryLoadTimer = null;
-            this.load(callback, retryCount);
-        }, sleepSeconds * 1000);
-    }
-    patchReceived(patch) {
-        const buffer = this.bufferedPatches;
-        buffer.push(patch);
-        if (this.bufferTimer)
-            return;
-        this.bufferTimer = setTimeout(() => {
-            this.bufferTimer = null;
-            this.bufferedPatches;
-            const buf = this.bufferedPatches;
-            this.bufferedPatches = [];
-            const { changes, events } = this.store.batchUpdate(buf);
-            this.data = this.store.data;
-            changes.forEach(change => this.trigger('change', change));
-            events.forEach(event => {
-                this.trigger(event.type, event.data);
-            });
-        }, 16);
-    }
-    subscribe(event, callback) {
-        let listeners = this.eventListeners.events[event];
-        if (!listeners)
-            this.eventListeners.events[event] = listeners = {};
-        const id = this.eventListeners.serial++;
-        listeners[id] = callback;
-        return { unsubscribe: () => { delete listeners[id]; } };
-    }
-    trigger(event, arg) {
-        const listeners = this.eventListeners.events[event];
-        if (!listeners)
-            return;
-        for (const id in listeners)
-            listeners[id](arg);
-    }
-    initializeStore(keys, data, option) {
-        this.complete = true;
-        if (!keys) {
-            this.notfound = true;
-            return;
-        }
-        this.notfound = false;
-        const query = this.request.query;
-        if (this.store) {
-            this.store.replaceData(data);
-        }
-        else {
-            this.store = new ArSyncStore_1.default(query, data, option);
-            this.data = this.store.data;
-        }
-        this.subscriptions = keys.map(key => {
-            return ArSyncRecord.connectionManager.subscribe(key, patch => this.patchReceived(patch));
-        });
-    }
-}
-class ArSyncModel extends ArSyncModelBase_1.default {
-    static setConnectionAdapter(adapter) {
-        ArSyncRecord.connectionManager = new ConnectionManager_1.default(adapter);
-    }
-    static createRefModel(request, option) {
-        return new ArSyncRecord(request, option);
-    }
-    refManagerClass() {
-        return ArSyncModel;
-    }
-    connectionManager() {
-        return ArSyncRecord.connectionManager;
-    }
-}
-ArSyncModel._cache = {};
-ArSyncModel.cacheTimeout = 10 * 1000;
-exports.default = ArSyncModel;

data/tree/ArSyncStore.d.ts

@@ -1,21 +0,0 @@
-export default class ArSyncStore {
-    data: any;
-    query: any;
-    immutable: any;
-    constructor(query: any, data: any, option?: {
-        immutable?: boolean | undefined;
-    });
-    replaceData(data: any): void;
-    batchUpdate(patches: any): {
-        changes: any;
-        events: never[];
-    };
-    update(patch: any): {
-        changes: any;
-        events: never[];
-    };
-    _slicePatch(patchData: any, query: any): {};
-    _applyPatch(data: any, accessKeys: any, actualPath: any, updator: any, query: any, patchData: any): void;
-    _update(patch: any, updator: any, events: any): void;
-    static parseQuery(query: any, attrsonly?: any): {};
-}

data/tree/ArSyncStore.js

@@ -1,365 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-class Updator {
-    constructor(immutable) {
-        this.changes = [];
-        this.markedForFreezeObjects = [];
-        this.immutable = immutable;
-    }
-    static createFrozenObject(obj) {
-        if (!obj)
-            return obj;
-        if (obj.constructor === Array) {
-            obj = obj.map(el => Updator.createFrozenObject(el));
-        }
-        else if (typeof obj === 'object') {
-            obj = Object.assign({}, obj);
-            for (const key in obj) {
-                obj[key] = Updator.createFrozenObject(obj[key]);
-            }
-        }
-        Object.freeze(obj);
-        return obj;
-    }
-    replaceData(data, newData) {
-        if (this.immutable)
-            return Updator.createFrozenObject(newData);
-        return this.recursivelyReplaceData(data, newData);
-    }
-    recursivelyReplaceData(data, newData) {
-        const replaceArray = (as, bs) => {
-            const aids = {};
-            for (const a of as) {
-                if (!a.id)
-                    return false;
-                aids[a.id] = a;
-            }
-            const order = {};
-            bs.forEach((b, i) => {
-                if (!b.id)
-                    return false;
-                if (aids[b.id]) {
-                    replaceObject(aids[b.id], b);
-                }
-                else {
-                    as.push(b);
-                }
-                order[b.id] = i + 1;
-            });
-            as.sort((a, b) => {
-                const oa = order[a.id] || Infinity;
-                const ob = order[b.id] || Infinity;
-                return oa > ob ? +1 : oa < ob ? -1 : 0;
-            });
-            while (as.length && !order[as[as.length - 1].id])
-                as.pop();
-            return true;
-        };
-        const replaceObject = (aobj, bobj) => {
-            const keys = {};
-            for (const key in aobj)
-                keys[key] = true;
-            for (const key in bobj)
-                keys[key] = true;
-            for (const key in keys) {
-                const a = aobj[key];
-                const b = bobj[key];
-                if ((a instanceof Array) && (b instanceof Array)) {
-                    if (!replaceArray(a, b))
-                        aobj[key] = b;
-                }
-                else if (a && b && (typeof a === 'object') && (typeof b === 'object') && !(a instanceof Array) && !(b instanceof Array)) {
-                    replaceObject(a, b);
-                }
-                else if (a !== b) {
-                    aobj[key] = b;
-                }
-            }
-        };
-        replaceObject(data, newData);
-        return data;
-    }
-    mark(obj) {
-        if (!this.immutable)
-            return obj;
-        if (!Object.isFrozen(this.data))
-            return obj;
-        const mobj = (obj.constructor === Array) ? [...obj] : Object.assign({}, obj);
-        this.markedForFreezeObjects.push(mobj);
-        return mobj;
-    }
-    trace(data, path) {
-        path.forEach(key => {
-            if (this.immutable)
-                data[key] = this.mark(data[key]);
-            data = data[key];
-        });
-        return data;
-    }
-    assign(el, path, column, value, orderParam) {
-        if (this.immutable)
-            value = Updator.createFrozenObject(value);
-        if (el.constructor === Array && !el[column]) {
-            this.changes.push({
-                path: path.concat([value.id]),
-                target: el,
-                id: value.id,
-                valueWas: null,
-                value
-            });
-            const limitReached = orderParam && orderParam.limit != null && el.length === orderParam.limit;
-            let removed;
-            if (orderParam && orderParam.order == 'desc') {
-                el.unshift(value);
-                if (limitReached)
-                    removed = el.pop();
-            }
-            else {
-                el.push(value);
-                if (limitReached)
-                    removed = el.pop();
-            }
-            if (removed)
-                this.changes.push({
-                    path: path.concat([removed.id]),
-                    target: el,
-                    id: removed.id,
-                    valueWas: removed,
-                    value: null
-                });
-        }
-        else if (!this.valueEquals(el[column], value)) {
-            this.changes.push({
-                path: path.concat([column]),
-                target: el,
-                column: column,
-                valueWas: el[column],
-                value
-            });
-            el[column] = value;
-        }
-    }
-    valueEquals(a, b) {
-        if (a === b)
-            return true;
-        if (!a || !b)
-            return a == b;
-        if (typeof a !== 'object')
-            return false;
-        if (typeof b !== 'object')
-            return false;
-        const ja = JSON.stringify(a);
-        const jb = JSON.stringify(b);
-        return ja === jb;
-    }
-    add(tree, accessKeys, path, column, value, orderParam) {
-        const root = this.mark(tree);
-        const data = this.trace(root, accessKeys);
-        if (data)
-            this.assign(data, path, column, value, orderParam);
-        return root;
-    }
-    remove(tree, accessKeys, path, column) {
-        const root = this.mark(tree);
-        let data = this.trace(root, accessKeys);
-        if (!data)
-            return root;
-        if (data.constructor === Array) {
-            this.changes.push({
-                path: path.concat([data[column].id]),
-                target: data,
-                id: data[column].id,
-                valueWas: data[column],
-                value: null
-            });
-            data.splice(column, 1);
-        }
-        else if (data[column] !== null) {
-            this.changes.push({
-                path: path.concat([column]),
-                target: data,
-                column: column,
-                valueWas: data[column],
-                value: null
-            });
-            data[column] = null;
-        }
-        return root;
-    }
-    cleanup() {
-        this.markedForFreezeObjects.forEach(mobj => Object.freeze(mobj));
-    }
-}
-class ArSyncStore {
-    constructor(query, data, option = {}) {
-        this.data = option.immutable ? Updator.createFrozenObject(data) : data;
-        this.query = ArSyncStore.parseQuery(query);
-        this.immutable = option.immutable;
-    }
-    replaceData(data) {
-        this.data = new Updator(this.immutable).replaceData(this.data, data);
-    }
-    batchUpdate(patches) {
-        const events = [];
-        const updator = new Updator(this.immutable);
-        patches.forEach(patch => this._update(patch, updator, events));
-        updator.cleanup();
-        return { changes: updator.changes, events };
-    }
-    update(patch) {
-        return this.batchUpdate([patch]);
-    }
-    _slicePatch(patchData, query) {
-        const obj = {};
-        for (const key in patchData) {
-            if (key === 'id' || query.attributes['*']) {
-                obj[key] = patchData[key];
-            }
-            else {
-                const subq = query.attributes[key];
-                if (subq) {
-                    obj[subq.column || key] = patchData[key];
-                }
-            }
-        }
-        return obj;
-    }
-    _applyPatch(data, accessKeys, actualPath, updator, query, patchData) {
-        for (const key in patchData) {
-            const subq = query.attributes[key];
-            const value = patchData[key];
-            if (subq || query.attributes['*']) {
-                const subcol = (subq && subq.column) || key;
-                if (data[subcol] !== value) {
-                    this.data = updator.add(this.data, accessKeys, actualPath, subcol, value);
-                }
-            }
-        }
-    }
-    _update(patch, updator, events) {
-        const { action, path } = patch;
-        const patchData = patch.data;
-        let query = this.query;
-        let data = this.data;
-        const actualPath = [];
-        const accessKeys = [];
-        for (let i = 0; i < path.length - 1; i++) {
-            const nameOrId = path[i];
-            if (typeof (nameOrId) === 'number') {
-                const idx = data.findIndex(o => o.id === nameOrId);
-                if (idx < 0)
-                    return;
-                actualPath.push(nameOrId);
-                accessKeys.push(idx);
-                data = data[idx];
-            }
-            else {
-                const { attributes } = query;
-                if (!attributes[nameOrId])
-                    return;
-                const column = attributes[nameOrId].column || nameOrId;
-                query = attributes[nameOrId];
-                actualPath.push(column);
-                accessKeys.push(column);
-                data = data[column];
-            }
-            if (!data)
-                return;
-        }
-        const nameOrId = path[path.length - 1];
-        let id, idx, column, target = data;
-        if (typeof (nameOrId) === 'number') {
-            id = nameOrId;
-            idx = data.findIndex(o => o.id === id);
-            target = data[idx];
-        }
-        else if (nameOrId) {
-            const { attributes } = query;
-            if (!attributes[nameOrId])
-                return;
-            column = attributes[nameOrId].column || nameOrId;
-            query = attributes[nameOrId];
-            target = data[column];
-        }
-        if (action === 'create') {
-            const obj = this._slicePatch(patchData, query);
-            if (column) {
-                this.data = updator.add(this.data, accessKeys, actualPath, column, obj);
-            }
-            else if (!target) {
-                const ordering = Object.assign({}, patch.ordering);
-                const limitOverride = query.params && query.params.limit;
-                ordering.order = query.params && query.params.order || ordering.order;
-                if (ordering.limit == null || limitOverride != null && limitOverride < ordering.limit)
-                    ordering.limit = limitOverride;
-                this.data = updator.add(this.data, accessKeys, actualPath, data.length, obj, ordering);
-            }
-            return;
-        }
-        if (action === 'destroy') {
-            if (column) {
-                this.data = updator.remove(this.data, accessKeys, actualPath, column);
-            }
-            else if (idx >= 0) {
-                this.data = updator.remove(this.data, accessKeys, actualPath, idx);
-            }
-            return;
-        }
-        if (!target)
-            return;
-        if (column) {
-            actualPath.push(column);
-            accessKeys.push(column);
-        }
-        else if (id) {
-            actualPath.push(id);
-            accessKeys.push(idx);
-        }
-        if (action === 'update') {
-            this._applyPatch(target, accessKeys, actualPath, updator, query, patchData);
-        }
-        else {
-            const eventData = { target, path: actualPath, data: patchData.data };
-            events.push({ type: patchData.type, data: eventData });
-        }
-    }
-    static parseQuery(query, attrsonly) {
-        const attributes = {};
-        let column = null;
-        let params = null;
-        if (query.constructor !== Array)
-            query = [query];
-        for (const arg of query) {
-            if (typeof (arg) === 'string') {
-                attributes[arg] = {};
-            }
-            else if (typeof (arg) === 'object') {
-                for (const key in arg) {
-                    const value = arg[key];
-                    if (attrsonly) {
-                        attributes[key] = this.parseQuery(value);
-                        continue;
-                    }
-                    if (key === 'attributes') {
-                        const child = this.parseQuery(value, true);
-                        for (const k in child)
-                            attributes[k] = child[k];
-                    }
-                    else if (key === 'as') {
-                        column = value;
-                    }
-                    else if (key === 'params') {
-                        params = value;
-                    }
-                    else {
-                        attributes[key] = this.parseQuery(value);
-                    }
-                }
-            }
-        }
-        if (attrsonly)
-            return attributes;
-        return { attributes, column, params };
-    }
-}
-exports.default = ArSyncStore;