all files / documents/document/internal/ object.js

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
 
 
 
 
1×
143×
143×
125×
 
18×
 
 
 
 
 
4×
 
 
 
97×
97×
 
 
 
22×
 
 
 
180×
180×
 
180×
 
180×
149×
3×
 
146×
 
149×
149×
 
 
180×
 
 
 
118×
 
 
 
17×
 
 
 
118×
 
 
 
15×
 
 
 
54×
 
 
 
 
 
113×
113×
143×
143×
143×
 
113×
 
 
 
65×
65×
65×
104×
104×
104×
 
65×
 
 
 
 
 
import InternalBase from './base';
import EmptyObject from 'documents/util/empty-object';
import { toModel } from 'documents/util/internal';
 
const remove = (array, element) => {
  let idx = array.indexOf(element);
  if(idx === -1) {
    return;
  }
  array.splice(idx, 1);
};
 
export default class InternalObject extends InternalBase {
 
  static get type() {
    return 'object';
  }
 
  constructor(store, parent) {
    super(store, parent);
    this.values = new EmptyObject();
  }
 
  _createModel() {
    return this.store._createObjectModel(this);
  }
 
  _setValue(key, value, type, changed) {
    let values = this.values;
    let current = values[key];
 
    let { update, internal } = this._deserializeValue(value, current, type);
 
    if(update) {
      if(internal === undefined) {
        delete values[key];
      } else {
        values[key] = internal;
      }
      changed(key);
      this._dirty(changed);
    }
 
    return internal;
  }
 
  _getValue(key) {
    return this.values[key];
  }
 
  _setValueNotify(key, value, type) {
    return this.withPropertyChanges(changed => this._setValue(key, value, type, changed), true);
  }
 
  _getValueNotify(key, type) {
    return this.withPropertyChanges(changed => this._getValue(key, type, changed), true);
  }
 
  setValue(key, value) {
    return toModel(this._setValueNotify(key, value, 'model'));
  }
 
  getValue(key) {
    return toModel(this._getValueNotify(key, 'model'));
  }
 
  //
 
  _deserialize(values, type, changed) {
    let keys = Object.keys(this.values);
    for(let key in values) {
      remove(keys, key);
      let value = values[key];
      this._setValue(key, value, type, changed);
    }
    keys.forEach(key => this._setValue(key, undefined, type, changed));
  }
 
  _serialize(type) {
    let json = {};
    let values = this.values;
    for(let key in values) {
      let value = values[key];
      value = this._serializeValue(value, type);
      json[key] = value;
    }
    return json;
  }
 
}