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
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
|
import { observable, action } from "mobx";
import { serializable, primitive, map, alias, list } from "serializr";
import { autoObject, SerializationHelper, Deserializable } from "../client/util/SerializationHelper";
import { Utils } from "../Utils";
import { DocServer } from "../client/DocServer";
import { setter, getter, getField } from "./util";
import { Cast, ToConstructor, PromiseValue, FieldValue } from "./Types";
import { UndoManager, undoBatch } from "../client/util/UndoManager";
import { listSpec } from "./Schema";
import { List } from "./List";
import { ObjectField } from "./ObjectField";
import { RefField, FieldId, Id } from "./RefField";
export function IsField(field: any): field is Field {
return (typeof field === "string")
|| (typeof field === "number")
|| (typeof field === "boolean")
|| (field instanceof ObjectField)
|| (field instanceof RefField);
}
export type Field = number | string | boolean | ObjectField | RefField;
export type Opt<T> = T | undefined;
export type FieldWaiting<T extends RefField = RefField> = T extends undefined ? never : Promise<T | undefined>;
export type FieldResult<T extends Field = Field> = Opt<T> | FieldWaiting<Extract<T, RefField>>;
export const Update = Symbol("Update");
export const Self = Symbol("Self");
@Deserializable("doc").withFields(["id"])
export class Doc extends RefField {
constructor(id?: FieldId, forceSave?: boolean) {
super(id);
const doc = new Proxy<this>(this, {
set: setter,
get: getter,
ownKeys: target => Object.keys(target.__fields),
deleteProperty: () => { throw new Error("Currently properties can't be deleted from documents, assign to undefined instead"); },
defineProperty: () => { throw new Error("Currently properties can't be defined on documents using Object.defineProperty"); },
});
if (!id || forceSave) {
DocServer.CreateField(SerializationHelper.Serialize(doc));
}
return doc;
}
proto: Opt<Doc>;
[key: string]: FieldResult;
@serializable(alias("fields", map(autoObject())))
@observable
//{ [key: string]: Field | FieldWaiting | undefined }
private __fields: any = {};
private [Update] = (diff: any) => {
DocServer.UpdateField(this[Id], diff);
}
private [Self] = this;
}
export namespace Doc {
// export function GetAsync(doc: Doc, key: string, ignoreProto: boolean = false): Promise<Field | undefined> {
// const self = doc[Self];
// return new Promise(res => getField(self, key, ignoreProto, res));
// }
// export function GetTAsync<T extends Field>(doc: Doc, key: string, ctor: ToConstructor<T>, ignoreProto: boolean = false): Promise<T | undefined> {
// return new Promise(async res => {
// const field = await GetAsync(doc, key, ignoreProto);
// return Cast(field, ctor);
// });
// }
export function Get(doc: Doc, key: string, ignoreProto: boolean = false): FieldResult {
const self = doc[Self];
return getField(self, key, ignoreProto);
}
export function GetT<T extends Field>(doc: Doc, key: string, ctor: ToConstructor<T>, ignoreProto: boolean = false): T | null | undefined {
return Cast(Get(doc, key, ignoreProto), ctor) as T | null | undefined;
}
export async function SetOnPrototype(doc: Doc, key: string, value: Field) {
const proto = doc.proto;
if (proto) {
proto[key] = value;
}
}
export function GetAllPrototypes(doc: Doc): Doc[] {
const protos: Doc[] = [];
let d: Opt<Doc> = doc;
while (d) {
protos.push(d);
d = FieldValue(d.proto);
}
return protos;
}
export function assign<K extends string>(doc: Doc, fields: Partial<Record<K, Opt<Field>>>) {
for (const key in fields) {
if (fields.hasOwnProperty(key)) {
const value = fields[key];
if (value !== undefined) {
doc[key] = value;
}
}
}
return doc;
}
export function MakeAlias(doc: Doc) {
const alias = new Doc;
PromiseValue(Cast(doc.proto, Doc)).then(proto => {
if (proto) {
alias.proto = proto;
}
});
return alias;
}
export function MakeCopy(doc: Doc, copyProto: boolean = false): Doc {
const copy = new Doc;
Object.keys(doc).forEach(async key => {
const field = await doc[key];
if (key === "proto" && copyProto) {
if (field instanceof Doc) {
copy[key] = Doc.MakeCopy(field);
}
} else {
if (field instanceof RefField) {
copy[key] = field;
} else if (field instanceof ObjectField) {
copy[key] = ObjectField.MakeCopy(field);
} else {
copy[key] = field;
}
}
});
return copy;
}
export function MakeLink(source: Doc, target: Doc): Doc {
let linkDoc = new Doc;
UndoManager.RunInBatch(() => {
linkDoc.title = "New Link";
linkDoc.linkDescription = "";
linkDoc.linkTags = "Default";
linkDoc.linkedTo = target;
linkDoc.linkedFrom = source;
let linkedFrom = Cast(target.linkedFromDocs, listSpec(Doc));
if (!linkedFrom) {
target.linkedFromDocs = linkedFrom = new List<Doc>();
}
linkedFrom.push(linkDoc);
let linkedTo = Cast(source.linkedToDocs, listSpec(Doc));
if (!linkedTo) {
source.linkedToDocs = linkedTo = new List<Doc>();
}
linkedTo.push(linkDoc);
}, "make link");
return linkDoc;
}
export function MakeDelegate(doc: Doc): Doc;
export function MakeDelegate(doc: Opt<Doc>): Opt<Doc>;
export function MakeDelegate(doc: Opt<Doc>): Opt<Doc> {
if (!doc) {
return undefined;
}
const delegate = new Doc();
//TODO Does this need to be doc[Self]?
delegate.proto = doc;
return delegate;
}
export const Prototype = Symbol("Prototype");
}
|
