@verdant-web/store 2.7.7-next.0 → 2.7.8

package/dist/esm/entities/Entity.js

@@ -1,516 +1,516 @@
-var _a, _b;
-import { assert, assignOid, cloneDeep, decomposeOid, EventSubscriber, isFileRef, isObjectRef, maybeGetOid, traverseCollectionFieldsAndApplyDefaults, } from '@verdant-web/common';
-import { processValueFiles } from '../files/utils.js';
-export const ADD_OPERATIONS = '@@addOperations';
-export const DELETE = '@@delete';
-export const REBASE = '@@rebase';
-const REFRESH = '@@refresh';
-export const DEEP_CHANGE = '@@deepChange';
-export function refreshEntity(entity, info) {
-    return entity[REFRESH](info);
-}
-export class Entity {
-    hasSubscribersToDeepChanges() {
-        return this.events.subscriberCount('changeDeep') > 0;
-    }
-    get hasSubscribers() {
-        var _c, _d;
-        if (this.events.totalSubscriberCount() > 0) {
-            return true;
-        }
-        // even if nobody subscribes directly to this entity, if a parent
-        // has a deep subscription that counts.
-        let parent = (_c = this.parent) === null || _c === void 0 ? void 0 : _c.deref();
-        while (parent) {
-            if (parent.hasSubscribersToDeepChanges()) {
-                return true;
-            }
-            parent = (_d = parent.parent) === null || _d === void 0 ? void 0 : _d.deref();
-        }
-        return false;
-    }
-    get deleted() {
-        return this._deleted;
-    }
-    get value() {
-        return this._current;
-    }
-    get isList() {
-        return Array.isArray(this._current);
-    }
-    get updatedAt() {
-        return this._updatedAt;
-    }
-    get deepUpdatedAt() {
-        if (this.cachedDeepUpdatedAt)
-            return this.cachedDeepUpdatedAt;
-        // iterate over all children and take the latest timestamp
-        let latest = this._updatedAt;
-        if (this.isList) {
-            this.forEach((child) => {
-                if (child instanceof Entity) {
-                    const childTimestamp = child.deepUpdatedAt;
-                    if (childTimestamp && (!latest || childTimestamp > latest)) {
-                        latest = childTimestamp;
-                    }
-                }
-            });
-        }
-        else {
-            this.values().forEach((child) => {
-                if (child instanceof Entity) {
-                    const childTimestamp = child.deepUpdatedAt;
-                    if (childTimestamp && (!latest || childTimestamp > latest)) {
-                        latest = childTimestamp;
-                    }
-                }
-            });
-        }
-        this.cachedDeepUpdatedAt = latest;
-        return latest;
-    }
-    get uid() {
-        return this.oid;
-    }
-    constructor({ oid, store, fieldSchema, cache, parent, onAllUnsubscribed, readonlyKeys = [], }) {
-        // if current is null, the entity was deleted.
-        this._current = null;
-        this._deleted = false;
-        this.cachedSnapshot = null;
-        this.cachedDestructure = null;
-        this.cachedDeepUpdatedAt = null;
-        this._updatedAt = null;
-        this[_a] = (info) => {
-            const { view, deleted, lastTimestamp } = this.cache.computeView(this.oid);
-            this._current = view;
-            const restored = this._deleted && !deleted;
-            this._deleted = deleted;
-            this.cachedDestructure = null;
-            this._updatedAt = lastTimestamp ? lastTimestamp : null;
-            this.cachedDeepUpdatedAt = null;
-            if (this._deleted) {
-                this.events.emit('delete', info);
-            }
-            else {
-                this.events.emit('change', info);
-                this[DEEP_CHANGE](this, info);
-            }
-            if (restored) {
-                this.cachedSnapshot = null;
-                this.events.emit('restore', info);
-            }
-        };
-        this[_b] = (source, info) => {
-            var _c;
-            this.cachedSnapshot = null;
-            this.cachedDeepUpdatedAt = null;
-            this.events.emit('changeDeep', source, info);
-            const parent = (_c = this.parent) === null || _c === void 0 ? void 0 : _c.deref();
-            if (parent) {
-                parent[DEEP_CHANGE](source, info);
-            }
-        };
-        this.getChildFieldSchema = (key) => {
-            if (this.fieldSchema.type === 'object') {
-                return this.fieldSchema.properties[key];
-            }
-            else if (this.fieldSchema.type === 'array') {
-                return this.fieldSchema.items;
-            }
-            else if (this.fieldSchema.type === 'map') {
-                return this.fieldSchema.values;
-            }
-            else if (this.fieldSchema.type === 'any') {
-                return this.fieldSchema;
-            }
-            throw new Error('Invalid field schema');
-        };
-        this.dispose = () => {
-            this.events.dispose();
-        };
-        this.subscribe = (event, callback) => {
-            const unsubscribe = this.events.subscribe(event, callback);
-            return unsubscribe;
-        };
-        this.addPatches = (patches) => {
-            this.store.addLocalOperations(patches);
-        };
-        this.cloneCurrent = () => {
-            if (this._current === undefined) {
-                return undefined;
-            }
-            return cloneDeep(this._current);
-        };
-        this.getSubObject = (oid, key) => {
-            const fieldSchema = this.getChildFieldSchema(key);
-            // this is a failure case, but trying to be graceful about it...
-            // @ts-ignore
-            // if (!fieldSchema) return null;
-            return this.cache.getEntity(oid, fieldSchema, this);
-        };
-        this.wrapValue = (value, key) => {
-            if (isObjectRef(value)) {
-                const oid = value.id;
-                const subObject = this.getSubObject(oid, key);
-                if (subObject) {
-                    return subObject;
-                }
-                throw new Error(`CACHE MISS: Subobject ${oid} does not exist on ${this.oid}`);
-            }
-            else if (isFileRef(value)) {
-                const file = this.store.getFile(value.id);
-                if (file) {
-                    file.subscribe('change', () => {
-                        this[DEEP_CHANGE](this, {
-                            isLocal: false,
-                        });
-                    });
-                    return file;
-                }
-            }
-            return value;
-        };
-        this.processInputValue = (value, key) => {
-            // disassociate incoming OIDs on values and generally break object
-            // references. cloning doesn't work on files so those are
-            // filtered out.
-            // The goal here is to be safe about a bunch of cases that could
-            // result in corrupt data, like...
-            // ent1.set('objField', ent2.get('objField'))
-            // or
-            // var shared = { foo: 'bar' };
-            // ent1.set('objField', shared);
-            // ent2.set('objField', shared);
-            // ... each of these would result in the same object being
-            // referenced in multiple entities, which could mean introduction
-            // of foreign OIDs, or one object being assigned different OIDs
-            // with unexpected results.
-            if (!(value instanceof File)) {
-                value = cloneDeep(value, false);
-            }
-            const fieldSchema = this.getChildFieldSchema(key);
-            if (fieldSchema) {
-                traverseCollectionFieldsAndApplyDefaults(value, fieldSchema);
-            }
-            return processValueFiles(value, this.store.addFile);
-        };
-        this.get = (key) => {
-            if (this.value === undefined || this.value === null) {
-                throw new Error('Cannot access deleted entity');
-            }
-            const value = this.value[key];
-            return this.wrapValue(value, key);
-        };
-        this.getAll = () => {
-            if (this.value === undefined || this.value === null) {
-                throw new Error('Cannot access deleted entity');
-            }
-            if (this.cachedDestructure)
-                return this.cachedDestructure;
-            let result;
-            if (Array.isArray(this.value)) {
-                result = this.value.map((value, index) => this.wrapValue(value, index));
-            }
-            else {
-                result = {};
-                for (const key in this.value) {
-                    result[key] = this.get(key);
-                }
-            }
-            this.cachedDestructure = result;
-            return result;
-        };
-        /**
-         * Returns a copy of the entity and all sub-objects as
-         * a plain object or array.
-         */
-        this.getSnapshot = () => {
-            var _c;
-            if (!this.value) {
-                return null;
-            }
-            if (this.deleted) {
-                return null;
-            }
-            if (this.cachedSnapshot) {
-                return this.cachedSnapshot;
-            }
-            let snapshot;
-            if (Array.isArray(this.value)) {
-                snapshot = this.value.map((item, idx) => {
-                    var _c;
-                    if (isObjectRef(item)) {
-                        return (_c = this.getSubObject(item.id, idx)) === null || _c === void 0 ? void 0 : _c.getSnapshot();
-                    }
-                    else if (isFileRef(item)) {
-                        return this.getFileSnapshot(item);
-                    }
-                    return item;
-                });
-            }
-            else {
-                snapshot = Object.assign({}, this.value);
-                for (const [key, value] of Object.entries(snapshot)) {
-                    if (isObjectRef(value)) {
-                        snapshot[key] = (_c = this.getSubObject(value.id, key)) === null || _c === void 0 ? void 0 : _c.getSnapshot();
-                    }
-                    else if (isFileRef(value)) {
-                        snapshot[key] = this.getFileSnapshot(value);
-                    }
-                }
-            }
-            assignOid(snapshot, this.oid);
-            this.cachedSnapshot = snapshot;
-            return snapshot;
-        };
-        /**
-         * Object methods
-         */
-        this.keys = () => {
-            return Object.keys(this.value || {});
-        };
-        this.entries = () => {
-            return Object.entries(this.getAll());
-        };
-        this.values = () => {
-            return Object.values(this.getAll());
-        };
-        this.set = (key, value) => {
-            if (this.readonlyKeys.includes(key)) {
-                throw new Error(`Cannot set readonly key ${key.toString()}`);
-            }
-            this.addPatches(this.store.patchCreator.createSet(this.oid, key, this.processInputValue(value, key)));
-        };
-        this.delete = (key) => {
-            if (Array.isArray(this.value)) {
-                this.addPatches(this.store.patchCreator.createListDelete(this.oid, key, 1));
-            }
-            else {
-                // the key must be deletable - i.e. optional in the schema
-                const deleteMode = this.getDeleteMode(key);
-                if (!deleteMode) {
-                    throw new Error(`Cannot delete key ${key} - the property is not marked as optional in the schema`);
-                }
-                if (deleteMode === 'delete') {
-                    this.addPatches(this.store.patchCreator.createRemove(this.oid, key));
-                }
-                else {
-                    this.addPatches(this.store.patchCreator.createSet(this.oid, key, null));
-                }
-            }
-        };
-        this.getDeleteMode = (key) => {
-            if (this.readonlyKeys.includes(key)) {
-                return false;
-            }
-            // 'any' is always deletable, and map values can be removed completely
-            if (this.fieldSchema.type === 'any' || this.fieldSchema.type === 'map') {
-                return 'delete';
-            }
-            if (this.fieldSchema.type === 'object') {
-                const property = this.fieldSchema.properties[key];
-                if (!property) {
-                    // huh, trying to delete a field that isn't specified
-                    // in the schema. we should use 'delete' mode.
-                    return 'delete';
-                }
-                if (property.type === 'any')
-                    return 'delete';
-                // map can't be nullable
-                // TODO: should it be?
-                if (property.type === 'map')
-                    return false;
-                // nullable properties can only be set null
-                if (property.nullable)
-                    return 'null';
-            }
-            // no other parent objects support deleting
-            return false;
-        };
-        /** @deprecated - renamed to delete */
-        this.remove = this.delete.bind(this);
-        this.update = (value, { replaceSubObjects = false, merge = true, } = {
-            /**
-             * If true, merged sub-objects will be replaced entirely if there's
-             * ambiguity about their identity.
-             */
-            replaceSubObjects: false,
-            /**
-             * If false, omitted keys will erase their respective fields.
-             */
-            merge: true,
-        }) => {
-            if (!merge &&
-                this.fieldSchema.type !== 'any' &&
-                this.fieldSchema.type !== 'map') {
-                throw new Error('Cannot use .update without merge if the field has a strict schema type. merge: false is only available on "any" or "map" types.');
-            }
-            for (const [key, field] of Object.entries(value)) {
-                if (this.readonlyKeys.includes(key)) {
-                    throw new Error(`Cannot set readonly key ${key.toString()}`);
-                }
-                const fieldSchema = this.getChildFieldSchema(key);
-                if (fieldSchema) {
-                    traverseCollectionFieldsAndApplyDefaults(field, fieldSchema);
-                }
-            }
-            const withoutFiles = processValueFiles(value, this.store.addFile);
-            this.addPatches(this.store.patchCreator.createDiff(this.getSnapshot(), assignOid(withoutFiles, this.oid), {
-                mergeUnknownObjects: !replaceSubObjects,
-                defaultUndefined: merge,
-            }));
-        };
-        /**
-         * List methods
-         */
-        /**
-         * Returns the referent value of an item in the list, used for
-         * operations which act on items. if the item is an object,
-         * it will attempt to create an OID reference to it. If it
-         * is a primitive, it will return the primitive.
-         */
-        this.getItemRefValue = (item) => {
-            if (typeof item === 'object') {
-                const itemOid = maybeGetOid(item);
-                if (!itemOid || !this.cache.hasOid(itemOid)) {
-                    throw new Error(`Cannot move object ${JSON.stringify(item)} which does not exist in this list`);
-                }
-                return itemOid;
-            }
-            else {
-                return item;
-            }
-        };
-        this.push = (value) => {
-            this.addPatches(this.store.patchCreator.createListPush(this.oid, this.processInputValue(value, this.value.length)));
-        };
-        this.insert = (index, value) => {
-            this.addPatches(this.store.patchCreator.createListInsert(this.oid, index, this.processInputValue(value, index)));
-        };
-        this.move = (from, to) => {
-            this.addPatches(this.store.patchCreator.createListMoveByIndex(this.oid, from, to));
-        };
-        this.moveItem = (item, to) => {
-            const itemRef = this.getItemRefValue(item);
-            if (isObjectRef(itemRef)) {
-                this.addPatches(this.store.patchCreator.createListMoveByRef(this.oid, itemRef, to));
-            }
-            else {
-                const index = this.value.indexOf(itemRef);
-                this.addPatches(this.store.patchCreator.createListMoveByIndex(this.oid, index, to));
-            }
-        };
-        this.removeAll = (item) => {
-            this.addPatches(this.store.patchCreator.createListRemove(this.oid, this.getItemRefValue(item)));
-        };
-        this.removeFirst = (item) => {
-            this.addPatches(this.store.patchCreator.createListRemove(this.oid, this.getItemRefValue(item), 'first'));
-        };
-        this.removeLast = (item) => {
-            this.addPatches(this.store.patchCreator.createListRemove(this.oid, this.getItemRefValue(item), 'last'));
-        };
-        this.add = (item) => {
-            this.addPatches(this.store.patchCreator.createListAdd(this.oid, this.processInputValue(item, this.value.length)));
-        };
-        this.has = (item) => {
-            if (typeof item === 'object') {
-                return this.value.some((val) => {
-                    if (isObjectRef(val))
-                        return val.id === maybeGetOid(item);
-                    // Sets of files don't work right now, there's no way to compare them
-                    // effectively.
-                    if (isFileRef(val))
-                        return false;
-                    return false;
-                });
-            }
-            return this.value.includes(item);
-        };
-        // additional access methods
-        this.getAsWrapped = () => {
-            if (!this.isList)
-                throw new Error('Cannot map items of a non-list');
-            return this.value.map(this.wrapValue);
-        };
-        this.map = (callback) => {
-            return this.getAsWrapped().map(callback);
-        };
-        this.filter = (callback) => {
-            return this.getAsWrapped().filter((val, index) => {
-                return callback(val, index);
-            });
-        };
-        this.forEach = (callback) => {
-            this.getAsWrapped().forEach(callback);
-        };
-        this.some = (predicate) => {
-            return this.getAsWrapped().some(predicate);
-        };
-        this.every = (predicate) => {
-            return this.getAsWrapped().every(predicate);
-        };
-        this.find = (predicate) => {
-            return this.getAsWrapped().find(predicate);
-        };
-        this.includes = (item) => {
-            return this.has(item);
-        };
-        this.oid = oid;
-        const { collection } = decomposeOid(oid);
-        this.collection = collection;
-        this.store = store;
-        this.fieldSchema = fieldSchema;
-        this.readonlyKeys = readonlyKeys;
-        this.cache = cache;
-        this.parent = parent && this.cache.weakRef(parent);
-        const { view, deleted, lastTimestamp } = this.cache.computeView(oid);
-        this._current = view;
-        this._deleted = deleted;
-        this._updatedAt = lastTimestamp ? lastTimestamp : null;
-        this.cachedDeepUpdatedAt = null;
-        this.events = new EventSubscriber(() => {
-            if (!this.hasSubscribers) {
-                onAllUnsubscribed === null || onAllUnsubscribed === void 0 ? void 0 : onAllUnsubscribed();
-            }
-        });
-        if (this.oid.includes('.') && !this.parent) {
-            throw new Error('Parent must be provided for sub entities');
-        }
-        assert(!!fieldSchema, 'Field schema must be provided');
-    }
-    getFileSnapshot(item) {
-        const file = this.store.getFile(item.id);
-        if (file.url) {
-            return { id: item.id, url: file.url };
-        }
-        else if (file.loading || file.failed) {
-            return { id: item.id, url: undefined };
-        }
-        else {
-            return { id: item.id, url: null };
-        }
-    }
-    get length() {
-        return this.value.length;
-    }
-    // list implements an iterator which maps items to wrapped
-    // versions
-    [(_a = REFRESH, _b = DEEP_CHANGE, Symbol.iterator)]() {
-        let index = 0;
-        return {
-            next: () => {
-                if (index < this.value.length) {
-                    return {
-                        value: this.get(index++),
-                        done: false,
-                    };
-                }
-                return {
-                    value: undefined,
-                    done: true,
-                };
-            },
-        };
-    }
-}
+var _a, _b;
+import { assert, assignOid, cloneDeep, decomposeOid, EventSubscriber, isFileRef, isObjectRef, maybeGetOid, traverseCollectionFieldsAndApplyDefaults, } from '@verdant-web/common';
+import { processValueFiles } from '../files/utils.js';
+export const ADD_OPERATIONS = '@@addOperations';
+export const DELETE = '@@delete';
+export const REBASE = '@@rebase';
+const REFRESH = '@@refresh';
+export const DEEP_CHANGE = '@@deepChange';
+export function refreshEntity(entity, info) {
+    return entity[REFRESH](info);
+}
+export class Entity {
+    hasSubscribersToDeepChanges() {
+        return this.events.subscriberCount('changeDeep') > 0;
+    }
+    get hasSubscribers() {
+        var _c, _d;
+        if (this.events.totalSubscriberCount() > 0) {
+            return true;
+        }
+        // even if nobody subscribes directly to this entity, if a parent
+        // has a deep subscription that counts.
+        let parent = (_c = this.parent) === null || _c === void 0 ? void 0 : _c.deref();
+        while (parent) {
+            if (parent.hasSubscribersToDeepChanges()) {
+                return true;
+            }
+            parent = (_d = parent.parent) === null || _d === void 0 ? void 0 : _d.deref();
+        }
+        return false;
+    }
+    get deleted() {
+        return this._deleted;
+    }
+    get value() {
+        return this._current;
+    }
+    get isList() {
+        return Array.isArray(this._current);
+    }
+    get updatedAt() {
+        return this._updatedAt;
+    }
+    get deepUpdatedAt() {
+        if (this.cachedDeepUpdatedAt)
+            return this.cachedDeepUpdatedAt;
+        // iterate over all children and take the latest timestamp
+        let latest = this._updatedAt;
+        if (this.isList) {
+            this.forEach((child) => {
+                if (child instanceof Entity) {
+                    const childTimestamp = child.deepUpdatedAt;
+                    if (childTimestamp && (!latest || childTimestamp > latest)) {
+                        latest = childTimestamp;
+                    }
+                }
+            });
+        }
+        else {
+            this.values().forEach((child) => {
+                if (child instanceof Entity) {
+                    const childTimestamp = child.deepUpdatedAt;
+                    if (childTimestamp && (!latest || childTimestamp > latest)) {
+                        latest = childTimestamp;
+                    }
+                }
+            });
+        }
+        this.cachedDeepUpdatedAt = latest;
+        return latest;
+    }
+    get uid() {
+        return this.oid;
+    }
+    constructor({ oid, store, fieldSchema, cache, parent, onAllUnsubscribed, readonlyKeys = [], }) {
+        // if current is null, the entity was deleted.
+        this._current = null;
+        this._deleted = false;
+        this.cachedSnapshot = null;
+        this.cachedDestructure = null;
+        this.cachedDeepUpdatedAt = null;
+        this._updatedAt = null;
+        this[_a] = (info) => {
+            const { view, deleted, lastTimestamp } = this.cache.computeView(this.oid);
+            this._current = view;
+            const restored = this._deleted && !deleted;
+            this._deleted = deleted;
+            this.cachedDestructure = null;
+            this._updatedAt = lastTimestamp ? lastTimestamp : null;
+            this.cachedDeepUpdatedAt = null;
+            if (this._deleted) {
+                this.events.emit('delete', info);
+            }
+            else {
+                this.events.emit('change', info);
+                this[DEEP_CHANGE](this, info);
+            }
+            if (restored) {
+                this.cachedSnapshot = null;
+                this.events.emit('restore', info);
+            }
+        };
+        this[_b] = (source, info) => {
+            var _c;
+            this.cachedSnapshot = null;
+            this.cachedDeepUpdatedAt = null;
+            this.events.emit('changeDeep', source, info);
+            const parent = (_c = this.parent) === null || _c === void 0 ? void 0 : _c.deref();
+            if (parent) {
+                parent[DEEP_CHANGE](source, info);
+            }
+        };
+        this.getChildFieldSchema = (key) => {
+            if (this.fieldSchema.type === 'object') {
+                return this.fieldSchema.properties[key];
+            }
+            else if (this.fieldSchema.type === 'array') {
+                return this.fieldSchema.items;
+            }
+            else if (this.fieldSchema.type === 'map') {
+                return this.fieldSchema.values;
+            }
+            else if (this.fieldSchema.type === 'any') {
+                return this.fieldSchema;
+            }
+            throw new Error('Invalid field schema');
+        };
+        this.dispose = () => {
+            this.events.dispose();
+        };
+        this.subscribe = (event, callback) => {
+            const unsubscribe = this.events.subscribe(event, callback);
+            return unsubscribe;
+        };
+        this.addPatches = (patches) => {
+            this.store.addLocalOperations(patches);
+        };
+        this.cloneCurrent = () => {
+            if (this._current === undefined) {
+                return undefined;
+            }
+            return cloneDeep(this._current);
+        };
+        this.getSubObject = (oid, key) => {
+            const fieldSchema = this.getChildFieldSchema(key);
+            // this is a failure case, but trying to be graceful about it...
+            // @ts-ignore
+            // if (!fieldSchema) return null;
+            return this.cache.getEntity(oid, fieldSchema, this);
+        };
+        this.wrapValue = (value, key) => {
+            if (isObjectRef(value)) {
+                const oid = value.id;
+                const subObject = this.getSubObject(oid, key);
+                if (subObject) {
+                    return subObject;
+                }
+                throw new Error(`CACHE MISS: Subobject ${oid} does not exist on ${this.oid}`);
+            }
+            else if (isFileRef(value)) {
+                const file = this.store.getFile(value.id);
+                if (file) {
+                    file.subscribe('change', () => {
+                        this[DEEP_CHANGE](this, {
+                            isLocal: false,
+                        });
+                    });
+                    return file;
+                }
+            }
+            return value;
+        };
+        this.processInputValue = (value, key) => {
+            // disassociate incoming OIDs on values and generally break object
+            // references. cloning doesn't work on files so those are
+            // filtered out.
+            // The goal here is to be safe about a bunch of cases that could
+            // result in corrupt data, like...
+            // ent1.set('objField', ent2.get('objField'))
+            // or
+            // var shared = { foo: 'bar' };
+            // ent1.set('objField', shared);
+            // ent2.set('objField', shared);
+            // ... each of these would result in the same object being
+            // referenced in multiple entities, which could mean introduction
+            // of foreign OIDs, or one object being assigned different OIDs
+            // with unexpected results.
+            if (!(value instanceof File)) {
+                value = cloneDeep(value, false);
+            }
+            const fieldSchema = this.getChildFieldSchema(key);
+            if (fieldSchema) {
+                traverseCollectionFieldsAndApplyDefaults(value, fieldSchema);
+            }
+            return processValueFiles(value, this.store.addFile);
+        };
+        this.get = (key) => {
+            if (this.value === undefined || this.value === null) {
+                throw new Error('Cannot access deleted entity');
+            }
+            const value = this.value[key];
+            return this.wrapValue(value, key);
+        };
+        this.getAll = () => {
+            if (this.value === undefined || this.value === null) {
+                throw new Error('Cannot access deleted entity');
+            }
+            if (this.cachedDestructure)
+                return this.cachedDestructure;
+            let result;
+            if (Array.isArray(this.value)) {
+                result = this.value.map((value, index) => this.wrapValue(value, index));
+            }
+            else {
+                result = {};
+                for (const key in this.value) {
+                    result[key] = this.get(key);
+                }
+            }
+            this.cachedDestructure = result;
+            return result;
+        };
+        /**
+         * Returns a copy of the entity and all sub-objects as
+         * a plain object or array.
+         */
+        this.getSnapshot = () => {
+            var _c;
+            if (!this.value) {
+                return null;
+            }
+            if (this.deleted) {
+                return null;
+            }
+            if (this.cachedSnapshot) {
+                return this.cachedSnapshot;
+            }
+            let snapshot;
+            if (Array.isArray(this.value)) {
+                snapshot = this.value.map((item, idx) => {
+                    var _c;
+                    if (isObjectRef(item)) {
+                        return (_c = this.getSubObject(item.id, idx)) === null || _c === void 0 ? void 0 : _c.getSnapshot();
+                    }
+                    else if (isFileRef(item)) {
+                        return this.getFileSnapshot(item);
+                    }
+                    return item;
+                });
+            }
+            else {
+                snapshot = Object.assign({}, this.value);
+                for (const [key, value] of Object.entries(snapshot)) {
+                    if (isObjectRef(value)) {
+                        snapshot[key] = (_c = this.getSubObject(value.id, key)) === null || _c === void 0 ? void 0 : _c.getSnapshot();
+                    }
+                    else if (isFileRef(value)) {
+                        snapshot[key] = this.getFileSnapshot(value);
+                    }
+                }
+            }
+            assignOid(snapshot, this.oid);
+            this.cachedSnapshot = snapshot;
+            return snapshot;
+        };
+        /**
+         * Object methods
+         */
+        this.keys = () => {
+            return Object.keys(this.value || {});
+        };
+        this.entries = () => {
+            return Object.entries(this.getAll());
+        };
+        this.values = () => {
+            return Object.values(this.getAll());
+        };
+        this.set = (key, value) => {
+            if (this.readonlyKeys.includes(key)) {
+                throw new Error(`Cannot set readonly key ${key.toString()}`);
+            }
+            this.addPatches(this.store.patchCreator.createSet(this.oid, key, this.processInputValue(value, key)));
+        };
+        this.delete = (key) => {
+            if (Array.isArray(this.value)) {
+                this.addPatches(this.store.patchCreator.createListDelete(this.oid, key, 1));
+            }
+            else {
+                // the key must be deletable - i.e. optional in the schema
+                const deleteMode = this.getDeleteMode(key);
+                if (!deleteMode) {
+                    throw new Error(`Cannot delete key ${key} - the property is not marked as optional in the schema`);
+                }
+                if (deleteMode === 'delete') {
+                    this.addPatches(this.store.patchCreator.createRemove(this.oid, key));
+                }
+                else {
+                    this.addPatches(this.store.patchCreator.createSet(this.oid, key, null));
+                }
+            }
+        };
+        this.getDeleteMode = (key) => {
+            if (this.readonlyKeys.includes(key)) {
+                return false;
+            }
+            // 'any' is always deletable, and map values can be removed completely
+            if (this.fieldSchema.type === 'any' || this.fieldSchema.type === 'map') {
+                return 'delete';
+            }
+            if (this.fieldSchema.type === 'object') {
+                const property = this.fieldSchema.properties[key];
+                if (!property) {
+                    // huh, trying to delete a field that isn't specified
+                    // in the schema. we should use 'delete' mode.
+                    return 'delete';
+                }
+                if (property.type === 'any')
+                    return 'delete';
+                // map can't be nullable
+                // TODO: should it be?
+                if (property.type === 'map')
+                    return false;
+                // nullable properties can only be set null
+                if (property.nullable)
+                    return 'null';
+            }
+            // no other parent objects support deleting
+            return false;
+        };
+        /** @deprecated - renamed to delete */
+        this.remove = this.delete.bind(this);
+        this.update = (value, { replaceSubObjects = false, merge = true, } = {
+            /**
+             * If true, merged sub-objects will be replaced entirely if there's
+             * ambiguity about their identity.
+             */
+            replaceSubObjects: false,
+            /**
+             * If false, omitted keys will erase their respective fields.
+             */
+            merge: true,
+        }) => {
+            if (!merge &&
+                this.fieldSchema.type !== 'any' &&
+                this.fieldSchema.type !== 'map') {
+                throw new Error('Cannot use .update without merge if the field has a strict schema type. merge: false is only available on "any" or "map" types.');
+            }
+            for (const [key, field] of Object.entries(value)) {
+                if (this.readonlyKeys.includes(key)) {
+                    throw new Error(`Cannot set readonly key ${key.toString()}`);
+                }
+                const fieldSchema = this.getChildFieldSchema(key);
+                if (fieldSchema) {
+                    traverseCollectionFieldsAndApplyDefaults(field, fieldSchema);
+                }
+            }
+            const withoutFiles = processValueFiles(value, this.store.addFile);
+            this.addPatches(this.store.patchCreator.createDiff(this.getSnapshot(), assignOid(withoutFiles, this.oid), {
+                mergeUnknownObjects: !replaceSubObjects,
+                defaultUndefined: merge,
+            }));
+        };
+        /**
+         * List methods
+         */
+        /**
+         * Returns the referent value of an item in the list, used for
+         * operations which act on items. if the item is an object,
+         * it will attempt to create an OID reference to it. If it
+         * is a primitive, it will return the primitive.
+         */
+        this.getItemRefValue = (item) => {
+            if (typeof item === 'object') {
+                const itemOid = maybeGetOid(item);
+                if (!itemOid || !this.cache.hasOid(itemOid)) {
+                    throw new Error(`Cannot move object ${JSON.stringify(item)} which does not exist in this list`);
+                }
+                return itemOid;
+            }
+            else {
+                return item;
+            }
+        };
+        this.push = (value) => {
+            this.addPatches(this.store.patchCreator.createListPush(this.oid, this.processInputValue(value, this.value.length)));
+        };
+        this.insert = (index, value) => {
+            this.addPatches(this.store.patchCreator.createListInsert(this.oid, index, this.processInputValue(value, index)));
+        };
+        this.move = (from, to) => {
+            this.addPatches(this.store.patchCreator.createListMoveByIndex(this.oid, from, to));
+        };
+        this.moveItem = (item, to) => {
+            const itemRef = this.getItemRefValue(item);
+            if (isObjectRef(itemRef)) {
+                this.addPatches(this.store.patchCreator.createListMoveByRef(this.oid, itemRef, to));
+            }
+            else {
+                const index = this.value.indexOf(itemRef);
+                this.addPatches(this.store.patchCreator.createListMoveByIndex(this.oid, index, to));
+            }
+        };
+        this.removeAll = (item) => {
+            this.addPatches(this.store.patchCreator.createListRemove(this.oid, this.getItemRefValue(item)));
+        };
+        this.removeFirst = (item) => {
+            this.addPatches(this.store.patchCreator.createListRemove(this.oid, this.getItemRefValue(item), 'first'));
+        };
+        this.removeLast = (item) => {
+            this.addPatches(this.store.patchCreator.createListRemove(this.oid, this.getItemRefValue(item), 'last'));
+        };
+        this.add = (item) => {
+            this.addPatches(this.store.patchCreator.createListAdd(this.oid, this.processInputValue(item, this.value.length)));
+        };
+        this.has = (item) => {
+            if (typeof item === 'object') {
+                return this.value.some((val) => {
+                    if (isObjectRef(val))
+                        return val.id === maybeGetOid(item);
+                    // Sets of files don't work right now, there's no way to compare them
+                    // effectively.
+                    if (isFileRef(val))
+                        return false;
+                    return false;
+                });
+            }
+            return this.value.includes(item);
+        };
+        // additional access methods
+        this.getAsWrapped = () => {
+            if (!this.isList)
+                throw new Error('Cannot map items of a non-list');
+            return this.value.map(this.wrapValue);
+        };
+        this.map = (callback) => {
+            return this.getAsWrapped().map(callback);
+        };
+        this.filter = (callback) => {
+            return this.getAsWrapped().filter((val, index) => {
+                return callback(val, index);
+            });
+        };
+        this.forEach = (callback) => {
+            this.getAsWrapped().forEach(callback);
+        };
+        this.some = (predicate) => {
+            return this.getAsWrapped().some(predicate);
+        };
+        this.every = (predicate) => {
+            return this.getAsWrapped().every(predicate);
+        };
+        this.find = (predicate) => {
+            return this.getAsWrapped().find(predicate);
+        };
+        this.includes = (item) => {
+            return this.has(item);
+        };
+        this.oid = oid;
+        const { collection } = decomposeOid(oid);
+        this.collection = collection;
+        this.store = store;
+        this.fieldSchema = fieldSchema;
+        this.readonlyKeys = readonlyKeys;
+        this.cache = cache;
+        this.parent = parent && this.cache.weakRef(parent);
+        const { view, deleted, lastTimestamp } = this.cache.computeView(oid);
+        this._current = view;
+        this._deleted = deleted;
+        this._updatedAt = lastTimestamp ? lastTimestamp : null;
+        this.cachedDeepUpdatedAt = null;
+        this.events = new EventSubscriber(() => {
+            if (!this.hasSubscribers) {
+                onAllUnsubscribed === null || onAllUnsubscribed === void 0 ? void 0 : onAllUnsubscribed();
+            }
+        });
+        if (this.oid.includes('.') && !this.parent) {
+            throw new Error('Parent must be provided for sub entities');
+        }
+        assert(!!fieldSchema, 'Field schema must be provided');
+    }
+    getFileSnapshot(item) {
+        const file = this.store.getFile(item.id);
+        if (file.url) {
+            return { id: item.id, url: file.url };
+        }
+        else if (file.loading || file.failed) {
+            return { id: item.id, url: undefined };
+        }
+        else {
+            return { id: item.id, url: null };
+        }
+    }
+    get length() {
+        return this.value.length;
+    }
+    // list implements an iterator which maps items to wrapped
+    // versions
+    [(_a = REFRESH, _b = DEEP_CHANGE, Symbol.iterator)]() {
+        let index = 0;
+        return {
+            next: () => {
+                if (index < this.value.length) {
+                    return {
+                        value: this.get(index++),
+                        done: false,
+                    };
+                }
+                return {
+                    value: undefined,
+                    done: true,
+                };
+            },
+        };
+    }
+}
 //# sourceMappingURL=Entity.js.map