ar_sync 1.0.1 → 1.0.2

data/graph/ArSyncModel.d.ts

@@ -1,10 +0,0 @@
-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

@@ -1,22 +0,0 @@
-"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/hooks.d.ts

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

data/graph/hooks.js

@@ -1,10 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-var hooksBase_1 = require("../core/hooksBase");
-exports.useArSyncFetch = hooksBase_1.useArSyncFetch;
-const hooksBase_2 = require("../core/hooksBase");
-const ArSyncModel_1 = require("./ArSyncModel");
-function useArSyncModel(request) {
-    return hooksBase_2.useArSyncModelWithClass(ArSyncModel_1.default, request);
-}
-exports.useArSyncModel = useArSyncModel;

data/graph/index.d.ts

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

data/graph/index.js

@@ -1,4 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const ArSyncModel_1 = require("./ArSyncModel");
-exports.default = ArSyncModel_1.default;

data/src/core/hooksBase.ts

@@ -1,86 +0,0 @@
-import { useState, useEffect, useCallback } from 'react'
-import ArSyncAPI from './ArSyncApi'
-
-interface ModelStatus { complete: boolean; notfound?: boolean; connected: boolean }
-export 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 function useArSyncModelWithClass<T>(modelClass: { new<T>(req: Request, option?: any): ArSyncModel<T> }, request: Request | null): DataAndStatus<T> {
-  const [data, setData] = useState<T | null>(null)
-  const [status, setStatus] = useState<ModelStatus>({ complete: false, connected: true })
-  const updateStatus = (complete: boolean, notfound: boolean | undefined, connected: boolean) => {
-    if (complete === status.complete || notfound === status.notfound || connected === status.notfound) return
-    setStatus({ complete, notfound, connected })
-  }
-  useEffect(() => {
-    if (!request) return () => {}
-    const model = new modelClass<T>(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]
-}
-
-
-interface FetchStatus { complete: boolean; notfound?: boolean }
-type DataAndStatusAndUpdater<T> = [T | null, FetchStatus, () => void]
-export function useArSyncFetch<T>(request: Request | null): DataAndStatusAndUpdater<T> {
-  const [response, setResponse] = useState<T | null>(null)
-  const [status, setStatus] = useState<FetchStatus>({ complete: false })
-  const requestString = JSON.stringify(request && request.params)
-  let canceled = false
-  let timer: number | null = null
-  const update = useCallback(() => {
-    if (!request) {
-      setStatus({ complete: false, notfound: undefined })
-      return () => {}
-    }
-    canceled = false
-    timer = null
-    const fetch = (count: number) => {
-      if (timer) clearTimeout(timer)
-      timer = null
-      ArSyncAPI.fetch(request)
-        .then((response) => {
-          if (canceled) return
-          setResponse(response as T)
-          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])
-  useEffect(() => {
-    update()
-    return () => {
-      canceled = true
-      if (timer) clearTimeout(timer)
-      timer = null
-    }
-  }, [requestString])
-  return [response, status, update]
-}

data/src/graph/ArSyncModel.ts

@@ -1,21 +0,0 @@
-import ArSyncStore from './ArSyncStore'
-import ArSyncConnectionManager from '../core/ConnectionManager'
-import ArSyncModelBase from '../core/ArSyncModelBase'
-import ConnectionAdapter from '../core/ConnectionAdapter'
-
-export default class ArSyncModel<T> extends ArSyncModelBase<T> {
-  static setConnectionAdapter(adapter: ConnectionAdapter) {
-    ArSyncStore.connectionManager = new ArSyncConnectionManager(adapter)
-  }
-  static createRefModel(request, option): any {
-    return new ArSyncStore(request, option)
-  }
-  refManagerClass() {
-    return ArSyncModel
-  }
-  connectionManager() {
-    return ArSyncStore.connectionManager
-  }
-  static _cache = {}
-  static cacheTimeout = 10 * 1000
-}

data/src/graph/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/graph/index.ts

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

data/src/tree/ArSyncModel.ts

@@ -1,145 +0,0 @@
-import ArSyncStore from './ArSyncStore'
-import ArSyncAPI from '../core/ArSyncApi'
-import ArSyncConnectionManager from '../core/ConnectionManager'
-import ArSyncModelBase from '../core/ArSyncModelBase'
-import ConnectionAdapter from '../core/ConnectionAdapter'
-
-class ArSyncRecord {
-  immutable
-  request
-  subscriptions
-  store
-  retryLoadTimer
-  data
-  bufferTimer
-  bufferedPatches
-  eventListeners
-  networkSubscription
-  complete: boolean
-  notfound?: boolean
-  static connectionManager
-  constructor(request, option = {} as { immutable?: boolean }) {
-    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.syncFetch(this.request).then(syncData => {
-      const { keys, data, limit, order } = syncData as any
-      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(query, data, option)
-      this.data = this.store.data
-    }
-    this.subscriptions = keys.map(key => {
-      return ArSyncRecord.connectionManager.subscribe(key, patch => this.patchReceived(patch))
-    })
-  }
-}
-
-export default class ArSyncModel<T> extends ArSyncModelBase<T> {
-  static setConnectionAdapter(adapter: ConnectionAdapter) {
-    ArSyncRecord.connectionManager = new ArSyncConnectionManager(adapter)
-  }
-  static createRefModel(request, option) {
-    return new ArSyncRecord(request, option)
-  }
-  refManagerClass() {
-    return ArSyncModel
-  }
-  connectionManager() {
-    return ArSyncRecord.connectionManager
-  }
-  static _cache = {}
-  static cacheTimeout = 10 * 1000
-}

data/src/tree/ArSyncStore.ts

@@ -1,323 +0,0 @@
-class Updator {
-  changes
-  markedForFreezeObjects
-  immutable
-  data
-  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] : { ...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))
-  }
-}
-
-export default class ArSyncStore {
-  data
-  query
-  immutable
-  constructor(query, data, option = {} as { immutable?: boolean }) {
-    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: (string | number)[] = []
-    const accessKeys: (string | number)[] = []
-    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 }
-  }
-}