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
|
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 } from "./Types";
export type FieldId = string;
export const HandleUpdate = Symbol("HandleUpdate");
export const Id = Symbol("Id");
export abstract class RefField {
@serializable(alias("id", primitive()))
private __id: FieldId;
readonly [Id]: FieldId;
constructor(id?: FieldId) {
this.__id = id || Utils.GenerateGuid();
this[Id] = this.__id;
}
protected [HandleUpdate]?(diff: any): void;
}
export const Update = Symbol("Update");
export const OnUpdate = Symbol("OnUpdate");
export const Parent = Symbol("Parent");
export class ObjectField {
protected [OnUpdate]?: (diff?: any) => void;
private [Parent]?: Doc;
readonly [Id] = "";
}
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 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,
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: FieldResult<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 = await Cast(doc.proto, Doc);
if (proto) {
proto[key] = value;
}
}
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 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");
}
export const GetAsync = Doc.GetAsync;
|
