houdini 0.13.7-alpha.3 → 0.13.7

package/build/cmd.js

@@ -2595,7 +2595,7 @@ pp$1$1.parseClass = function(node, isStatement) {
 };
 
 pp$1$1.parseClassElement = function(constructorAllowsSuper) {
-  var this$1$1 = this;
+  var this$1 = this;
 
   if (this.eat(types$2$1.semi)) { return null }
 
@@ -2603,14 +2603,14 @@ pp$1$1.parseClassElement = function(constructorAllowsSuper) {
   var tryContextual = function (k, noLineBreak) {
     if ( noLineBreak === void 0 ) noLineBreak = false;
 
-    var start = this$1$1.start, startLoc = this$1$1.startLoc;
-    if (!this$1$1.eatContextual(k)) { return false }
-    if (this$1$1.type !== types$2$1.parenL && (!noLineBreak || !this$1$1.canInsertSemicolon())) { return true }
-    if (method.key) { this$1$1.unexpected(); }
+    var start = this$1.start, startLoc = this$1.startLoc;
+    if (!this$1.eatContextual(k)) { return false }
+    if (this$1.type !== types$2$1.parenL && (!noLineBreak || !this$1.canInsertSemicolon())) { return true }
+    if (method.key) { this$1.unexpected(); }
     method.computed = false;
-    method.key = this$1$1.startNodeAt(start, startLoc);
+    method.key = this$1.startNodeAt(start, startLoc);
     method.key.name = k;
-    this$1$1.finishNode(method.key, "Identifier");
+    this$1.finishNode(method.key, "Identifier");
     return false
   };
 
@@ -5621,11 +5621,11 @@ pp$9$1.getToken = function() {
 // If we're in an ES6 environment, make parsers iterable
 if (typeof Symbol !== "undefined")
   { pp$9$1[Symbol.iterator] = function() {
-    var this$1$1 = this;
+    var this$1 = this;
 
     return {
       next: function () {
-        var token = this$1$1.getToken();
+        var token = this$1.getToken();
         return {
           done: token.type === types$2$1.eof,
           value: token
@@ -6531,10 +6531,10 @@ function visit$1(
 	return node;
 }
 
-var charToInteger$2 = {};
-var chars$2 = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=';
-for (var i$3 = 0; i$3 < chars$2.length; i$3++) {
-    charToInteger$2[chars$2.charCodeAt(i$3)] = i$3;
+var charToInteger = {};
+var chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=';
+for (var i$2 = 0; i$2 < chars.length; i$2++) {
+    charToInteger[chars.charCodeAt(i$2)] = i$2;
 }
 function decode(mappings) {
     var decoded = [];
@@ -6561,7 +6561,7 @@ function decode(mappings) {
             segment[0] = 0;
         }
         else {
-            var integer = charToInteger$2[c];
+            var integer = charToInteger[c];
             if (integer === undefined) {
                 throw new Error('Invalid character (' + String.fromCharCode(c) + ')');
             }
@@ -16411,10 +16411,10 @@ Object.keys(attribute_lookup$1).forEach(name => {
         metadata.property_name = name;
 });
 
-var charToInteger$1$1 = {};
-var chars$1$1 = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=';
-for (var i$2$2 = 0; i$2$2 < chars$1$1.length; i$2$2++) {
-    charToInteger$1$1[chars$1$1.charCodeAt(i$2$2)] = i$2$2;
+var charToInteger$1 = {};
+var chars$1 = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=';
+for (var i$2$1 = 0; i$2$1 < chars$1.length; i$2$1++) {
+    charToInteger$1[chars$1.charCodeAt(i$2$1)] = i$2$1;
 }
 function decode$1(mappings) {
     var decoded = [];
@@ -16441,7 +16441,7 @@ function decode$1(mappings) {
             segment[0] = 0;
         }
         else {
-            var integer = charToInteger$1$1[c];
+            var integer = charToInteger$1[c];
             if (integer === undefined) {
                 throw new Error('Invalid character (' + String.fromCharCode(c) + ')');
             }
@@ -16528,7 +16528,7 @@ function encodeInteger$1(num) {
         if (num > 0) {
             clamped |= 32;
         }
-        result += chars$1$1[clamped];
+        result += chars$1[clamped];
     } while (num > 0);
     return result;
 }
@@ -35890,13 +35890,10 @@ globSync$1.GlobSync = GlobSync$1;
 var fs$3 = fs$2$1;
 var rp$1 = fs_realpath;
 var minimatch$1 = minimatch_1;
-glob_1.Glob;
 var path$3 = path$6;
 var assert$3 = require$$1$3;
 var isAbsolute$1 = pathIsAbsolute.exports;
 var common$1 = common$2;
-common$1.alphasort;
-common$1.alphasorti;
 var setopts$1 = common$1.setopts;
 var ownProp$1 = common$1.ownProp;
 var childrenIgnored$1 = common$1.childrenIgnored;
@@ -36551,8 +36548,6 @@ var assert$2 = require$$1$3;
 var isAbsolute = pathIsAbsolute.exports;
 var globSync = sync;
 var common = common$2;
-common.alphasort;
-common.alphasorti;
 var setopts = common.setopts;
 var ownProp = common.ownProp;
 var inflight = inflight_1;
@@ -38625,7 +38620,7 @@ pp$1.parseClass = function(node, isStatement) {
 };
 
 pp$1.parseClassElement = function(constructorAllowsSuper) {
-  var this$1$1 = this;
+  var this$1 = this;
 
   if (this.eat(types$7.semi)) { return null }
 
@@ -38633,14 +38628,14 @@ pp$1.parseClassElement = function(constructorAllowsSuper) {
   var tryContextual = function (k, noLineBreak) {
     if ( noLineBreak === void 0 ) noLineBreak = false;
 
-    var start = this$1$1.start, startLoc = this$1$1.startLoc;
-    if (!this$1$1.eatContextual(k)) { return false }
-    if (this$1$1.type !== types$7.parenL && (!noLineBreak || !this$1$1.canInsertSemicolon())) { return true }
-    if (method.key) { this$1$1.unexpected(); }
+    var start = this$1.start, startLoc = this$1.startLoc;
+    if (!this$1.eatContextual(k)) { return false }
+    if (this$1.type !== types$7.parenL && (!noLineBreak || !this$1.canInsertSemicolon())) { return true }
+    if (method.key) { this$1.unexpected(); }
     method.computed = false;
-    method.key = this$1$1.startNodeAt(start, startLoc);
+    method.key = this$1.startNodeAt(start, startLoc);
     method.key.name = k;
-    this$1$1.finishNode(method.key, "Identifier");
+    this$1.finishNode(method.key, "Identifier");
     return false
   };
 
@@ -41651,11 +41646,11 @@ pp$9.getToken = function() {
 // If we're in an ES6 environment, make parsers iterable
 if (typeof Symbol !== "undefined")
   { pp$9[Symbol.iterator] = function() {
-    var this$1$1 = this;
+    var this$1 = this;
 
     return {
       next: function () {
-        var token = this$1$1.getToken();
+        var token = this$1.getToken();
         return {
           done: token.type === types$7.eof,
           value: token
@@ -42550,12 +42545,6 @@ function visit(
 	return node;
 }
 
-var charToInteger = {};
-var chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=';
-for (var i$2 = 0; i$2 < chars.length; i$2++) {
-    charToInteger[chars.charCodeAt(i$2)] = i$2;
-}
-
 // generate an ID that is, to all intents and purposes, unique
 const id = (Math.round(Math.random() * 1e20)).toString(36);
 const re = new RegExp(`_${id}_(?:(\\d+)|(AT)|(HASH))_(\\w+)?`, 'g');
@@ -50549,12 +50538,6 @@ Object.keys(attribute_lookup).forEach(name => {
         metadata.property_name = name;
 });
 
-var charToInteger$1 = {};
-var chars$1 = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=';
-for (var i$2$1 = 0; i$2$1 < chars$1.length; i$2$1++) {
-    charToInteger$1[chars$1.charCodeAt(i$2$1)] = i$2$1;
-}
-
 /* istanbul ignore next */
 (typeof URL !== 'undefined' ? URL : require('url').URL);
 

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "houdini",
-	"version": "0.13.7-alpha.3",
+	"version": "0.13.7",
 	"description": "The disappearing graphql client for SvelteKit",
 	"scripts": {
 		"build:runtime": "npm run build:runtime:cjs && npm run build:runtime:esm",
@@ -57,5 +57,5 @@
 		"rollup-plugin-preserve-shebangs": "^0.2.0",
 		"svelte": "^3.34.0"
 	},
-	"gitHead": "ee15950c805df12d854b3e91fc861d51e2ce2f0c"
+	"gitHead": "c83fd91b92e7be3b35604824c25d6fc0759fb458"
 }

package/build/runtime-esm/cache/list.d.ts

@@ -1,35 +0,0 @@
-import { SubscriptionSelection, ListWhen, SubscriptionSpec } from '../types';
-import { Cache } from './cache';
-import { Record } from './record';
-export declare class ListHandler {
-    readonly record: Record;
-    readonly key: string;
-    readonly listType: string;
-    private cache;
-    readonly selection: SubscriptionSelection;
-    private _when?;
-    private filters?;
-    readonly name: string;
-    readonly parentID: SubscriptionSpec['parentID'];
-    private connection;
-    constructor({ name, cache, record, key, listType, selection, when, filters, parentID, connection, }: {
-        name: string;
-        connection: boolean;
-        cache: Cache;
-        record: Record;
-        key: string;
-        listType: string;
-        selection: SubscriptionSelection;
-        when?: ListWhen;
-        filters?: ListHandler['filters'];
-        parentID?: SubscriptionSpec['parentID'];
-    });
-    when(when?: ListWhen): ListHandler;
-    append(selection: SubscriptionSelection, data: {}, variables?: {}): void;
-    prepend(selection: SubscriptionSelection, data: {}, variables?: {}): void;
-    addToList(selection: SubscriptionSelection, data: {}, variables: {}, where: 'first' | 'last'): void;
-    removeID(id: string, variables?: {}): void;
-    remove(data: {}, variables?: {}): void;
-    private validateWhen;
-    [Symbol.iterator](): Generator<Record, void, unknown>;
-}

package/build/runtime-esm/cache/list.js

@@ -1,203 +0,0 @@
-export class ListHandler {
-    constructor({ name, cache, record, key, listType, selection, when, filters, parentID, connection, }) {
-        this.record = record;
-        this.key = key;
-        this.listType = listType;
-        this.cache = cache;
-        this.selection = selection;
-        this._when = when;
-        this.filters = filters;
-        this.name = name;
-        this.parentID = parentID;
-        this.connection = connection;
-    }
-    // when applies a when condition to a new list pointing to the same spot
-    when(when) {
-        return new ListHandler({
-            cache: this.cache,
-            record: this.record,
-            key: this.key,
-            listType: this.listType,
-            selection: this.selection,
-            when,
-            filters: this.filters,
-            parentID: this.parentID,
-            name: this.name,
-            connection: this.connection,
-        });
-    }
-    append(selection, data, variables = {}) {
-        return this.addToList(selection, data, variables, 'last');
-    }
-    prepend(selection, data, variables = {}) {
-        return this.addToList(selection, data, variables, 'first');
-    }
-    addToList(selection, data, variables = {}, where) {
-        // figure out the id of the type we are adding
-        const dataID = this.cache.id(this.listType, data);
-        // if there are conditions for this operation
-        if (!this.validateWhen() || !dataID) {
-            return;
-        }
-        // we are going to implement the insert as a write with an update flag on a field
-        // that matches the key of the list. We'll have to embed the lists data and selection
-        // in the appropriate objects
-        let insertSelection = selection;
-        let insertData = data;
-        // if we are wrapping a connection, we have to embed the data under edges > node
-        if (this.connection) {
-            insertSelection = {
-                newEntry: {
-                    keyRaw: this.key,
-                    type: 'Connection',
-                    fields: {
-                        edges: {
-                            keyRaw: 'edges',
-                            type: 'ConnectionEdge',
-                            update: (where === 'first' ? 'prepend' : 'append'),
-                            fields: {
-                                node: {
-                                    type: this.listType,
-                                    keyRaw: 'node',
-                                    fields: {
-                                        ...selection,
-                                        __typename: {
-                                            keyRaw: '__typename',
-                                            type: 'String',
-                                        },
-                                    },
-                                },
-                            },
-                        },
-                    },
-                },
-            };
-            insertData = {
-                newEntry: {
-                    edges: [{ node: { ...data, __typename: this.listType } }],
-                },
-            };
-        }
-        else {
-            insertSelection = {
-                newEntries: {
-                    keyRaw: this.key,
-                    type: this.listType,
-                    update: (where === 'first' ? 'prepend' : 'append'),
-                    fields: {
-                        ...selection,
-                        __typename: {
-                            keyRaw: '__typename',
-                            type: 'String',
-                        },
-                    },
-                },
-            };
-            insertData = {
-                newEntries: [{ ...data, __typename: this.listType }],
-            };
-        }
-        // get the list of specs that are subscribing to the list
-        const subscribers = this.record.getSubscribers(this.key);
-        // look up the new record in the cache
-        const newRecord = this.cache.internal.record(dataID);
-        // walk down the list fields relative to the new record
-        // and make sure all of the list's subscribers are listening
-        // to that object
-        this.cache.internal.insertSubscribers(newRecord, selection, variables, ...subscribers);
-        // update the cache with the data we just found
-        this.cache.write({
-            selection: insertSelection,
-            data: insertData,
-            variables,
-            parent: this.record.id,
-            applyUpdates: true,
-        });
-    }
-    removeID(id, variables = {}) {
-        // if there are conditions for this operation
-        if (!this.validateWhen()) {
-            return;
-        }
-        // if we are removing from a connection, the id we are removing from
-        // has to be computed
-        let parentID = this.record.id;
-        let targetID = id;
-        let targetKey = this.key;
-        // if we are removing a record from a connection we have to walk through
-        // some embedded references first
-        if (this.connection) {
-            const embeddedConnection = this.record.linkedRecord(this.key);
-            if (!embeddedConnection) {
-                return;
-            }
-            // look at every embedded edge for the one with a node corresponding to the element
-            // we want to delete
-            for (const edge of embeddedConnection.flatLinkedList('edges') || []) {
-                if (!edge) {
-                    continue;
-                }
-                // look at the edge's node
-                const node = edge.linkedRecord('node');
-                if (!node) {
-                    continue;
-                }
-                // if we found the node
-                if (node.id === id) {
-                    targetID = edge.id;
-                }
-            }
-            parentID = embeddedConnection.id;
-            targetKey = 'edges';
-        }
-        // get the list of specs that are subscribing to the list
-        const subscribers = this.record.getSubscribers(this.key);
-        // disconnect record from any subscriptions associated with the list
-        this.cache.internal.unsubscribeSelection(this.cache.internal.record(targetID), 
-        // if we're unsubscribing from a connection, only unsubscribe from the target
-        this.connection ? this.selection.edges.fields : this.selection, variables, ...subscribers.map(({ set }) => set));
-        // remove the target from the parent
-        this.cache.internal.record(parentID).removeFromLinkedList(targetKey, targetID);
-        // notify the subscribers about the change
-        this.cache.internal.notifySubscribers(subscribers, variables);
-        // if we are removing from a connection, delete the embedded edge holding the record
-        if (this.connection) {
-            this.cache.internal.deleteID(targetID);
-        }
-    }
-    remove(data, variables = {}) {
-        const targetID = this.cache.id(this.listType, data);
-        if (!targetID) {
-            return;
-        }
-        // figure out the id of the type we are adding
-        this.removeID(targetID, variables);
-    }
-    validateWhen() {
-        // if this when doesn't apply, we should look at others to see if we should update those behind the scenes
-        let ok = true;
-        // if there are conditions for this operation
-        if (this._when) {
-            // we only NEED there to be target filters for must's
-            const targets = this.filters;
-            // check must's first
-            if (this._when.must && targets) {
-                ok = Object.entries(this._when.must).reduce((prev, [key, value]) => Boolean(prev && targets[key] == value), ok);
-            }
-            // if there are no targets, nothing could be true that can we compare against
-            if (this._when.must_not) {
-                ok =
-                    !targets ||
-                        Object.entries(this._when.must_not).reduce((prev, [key, value]) => Boolean(prev && targets[key] != value), ok);
-            }
-        }
-        return ok;
-    }
-    // iterating over the list handler should be the same as iterating over
-    // the underlying linked list
-    *[Symbol.iterator]() {
-        for (let record of this.record.flatLinkedList(this.key)) {
-            yield record;
-        }
-    }
-}

package/build/runtime-esm/cache/record.d.ts

@@ -1,40 +0,0 @@
-import { GraphQLValue, Maybe, SubscriptionSpec } from '../types';
-import { Cache, LinkedList } from './cache';
-export declare class Record {
-    fields: {
-        [key: string]: GraphQLValue;
-    };
-    keyVersions: {
-        [key: string]: Set<string>;
-    };
-    readonly id: string;
-    private subscribers;
-    private recordLinks;
-    listLinks: {
-        [key: string]: LinkedList;
-    };
-    private cache;
-    private referenceCounts;
-    private lifetimes;
-    constructor(cache: Cache, id: string);
-    allSubscribers(): SubscriptionSpec[];
-    getField(fieldName: string): GraphQLValue;
-    writeField(fieldName: string, value: GraphQLValue): void;
-    writeRecordLink(fieldName: string, value: string | null): void;
-    writeListLink(fieldName: string, value: LinkedList): void;
-    linkedRecord(fieldName: string): Record;
-    linkedRecordID(fieldName: string): string;
-    linkedListIDs(fieldName: string): (string | null)[];
-    flatLinkedList(fieldName: string): Maybe<Record>[];
-    appendLinkedList(fieldName: string, id: string): void;
-    prependLinkedList(fieldName: string, id: string): void;
-    removeFromLinkedList(fieldName: string, id: string): void;
-    addSubscriber(rawKey: string, key: string, ...specs: SubscriptionSpec[]): void;
-    getSubscribers(fieldName: string): SubscriptionSpec[];
-    forgetSubscribers(...targets: SubscriptionSpec[]): void;
-    removeAllSubscribers(): void;
-    removeAllSubscriptionVersions(keyRaw: string, spec: SubscriptionSpec): void;
-    private forgetSubscribers_walk;
-    removeSubscribers(fields: string[], sets: SubscriptionSpec['set'][]): void;
-    onGcTick(): void;
-}

package/build/runtime-esm/cache/record.js

@@ -1,195 +0,0 @@
-// for the most part, this is a very low-level/dumb class that is meant to track state related
-// to a specific entity in the cached graph.
-export class Record {
-    constructor(cache, id) {
-        this.fields = {};
-        this.keyVersions = {};
-        this.subscribers = {};
-        this.recordLinks = {};
-        this.listLinks = {};
-        this.referenceCounts = {};
-        this.lifetimes = new Map();
-        this.cache = cache;
-        this.id = id;
-    }
-    allSubscribers() {
-        return Object.values(this.subscribers).flatMap((subscribers) => subscribers);
-    }
-    getField(fieldName) {
-        return this.fields[fieldName];
-    }
-    writeField(fieldName, value) {
-        this.fields[fieldName] = value;
-    }
-    writeRecordLink(fieldName, value) {
-        this.recordLinks[fieldName] = value;
-    }
-    writeListLink(fieldName, value) {
-        this.listLinks[fieldName] = value;
-    }
-    linkedRecord(fieldName) {
-        const linkedRecord = this.recordLinks[fieldName];
-        if (linkedRecord === null) {
-            return null;
-        }
-        return this.cache.internal.getRecord(linkedRecord);
-    }
-    linkedRecordID(fieldName) {
-        return this.recordLinks[fieldName];
-    }
-    linkedListIDs(fieldName) {
-        const ids = [];
-        // we need to flatten the list links
-        const unvisited = [this.listLinks[fieldName] || []];
-        while (unvisited.length > 0) {
-            const target = unvisited.shift();
-            for (const id of target) {
-                if (Array.isArray(id)) {
-                    unvisited.push(id);
-                    continue;
-                }
-                ids.push(id);
-            }
-        }
-        return ids;
-    }
-    flatLinkedList(fieldName) {
-        return this.linkedListIDs(fieldName).map(this.cache.internal.getRecord);
-    }
-    appendLinkedList(fieldName, id) {
-        // this could be the first time we've seen the list
-        if (!this.listLinks[fieldName]) {
-            this.listLinks[fieldName] = [];
-        }
-        this.listLinks[fieldName].push(id);
-    }
-    prependLinkedList(fieldName, id) {
-        // this could be the first time we've seen the list
-        if (!this.listLinks[fieldName]) {
-            this.listLinks[fieldName] = [];
-        }
-        this.listLinks[fieldName].unshift(id);
-    }
-    removeFromLinkedList(fieldName, id) {
-        this.listLinks[fieldName] = (this.listLinks[fieldName] || []).filter((link) => link !== id);
-    }
-    addSubscriber(rawKey, key, ...specs) {
-        // if this is the first time we've seen the raw key
-        if (!this.keyVersions[rawKey]) {
-            this.keyVersions[rawKey] = new Set();
-        }
-        // add this version of the key if we need to
-        this.keyVersions[rawKey].add(key);
-        // the existing list
-        const existingSubscribers = (this.subscribers[key] || []).map(({ set }) => set);
-        // the list of new subscribers
-        const newSubscribers = specs.filter(({ set }) => !existingSubscribers.includes(set));
-        this.subscribers[key] = this.getSubscribers(key).concat(...newSubscribers);
-        // if this is the first time we've seen this key
-        if (!this.referenceCounts[key]) {
-            this.referenceCounts[key] = new Map();
-        }
-        const counts = this.referenceCounts[key];
-        // clear the lifetime count for the field
-        this.lifetimes.delete(key);
-        // increment the reference count for every subscriber
-        for (const spec of specs) {
-            // we're going to increment the current value by one
-            counts.set(spec.set, (counts.get(spec.set) || 0) + 1);
-        }
-    }
-    getSubscribers(fieldName) {
-        return this.subscribers[fieldName] || [];
-    }
-    forgetSubscribers(...targets) {
-        this.forgetSubscribers_walk(targets.map(({ set }) => set));
-    }
-    removeAllSubscribers() {
-        this.forgetSubscribers(...this.allSubscribers());
-    }
-    removeAllSubscriptionVersions(keyRaw, spec) {
-        // visit every version of the key we've seen and remove the spec from the list of subscribers
-        const versions = this.keyVersions[keyRaw];
-        // if there are no known versions, we're done
-        if (!versions) {
-            return;
-        }
-        this.removeSubscribers([...this.keyVersions[keyRaw]], [spec.set]);
-    }
-    forgetSubscribers_walk(targets, visited = []) {
-        var _a;
-        // clean up any subscribers that reference the set
-        this.removeSubscribers(Object.keys(this.subscribers), targets);
-        visited.push(this.id);
-        // walk down to every record we know about
-        const linkedIDs = Object.keys(this.recordLinks);
-        for (const key of Object.keys(this.listLinks)) {
-            for (const child of this.linkedListIDs(key)) {
-                if (child !== null) {
-                    linkedIDs.push(child);
-                }
-            }
-        }
-        for (const linkedRecordID of linkedIDs) {
-            if (visited.includes(linkedRecordID)) {
-                continue;
-            }
-            (_a = this.cache.internal.getRecord(linkedRecordID)) === null || _a === void 0 ? void 0 : _a.forgetSubscribers_walk(targets, visited);
-        }
-    }
-    removeSubscribers(fields, sets) {
-        var _a;
-        // clean up any subscribers that reference the set
-        for (const fieldName of fields) {
-            // build up a list of the sets we actually need to remove after
-            // checking reference counts
-            let targets = [];
-            for (const set of sets) {
-                // if we dont know this field/set combo, there's nothing to do (probably a bug somewhere)
-                if (!((_a = this.referenceCounts[fieldName]) === null || _a === void 0 ? void 0 : _a.has(set))) {
-                    continue;
-                }
-                const counts = this.referenceCounts[fieldName];
-                const newVal = (counts.get(set) || 0) - 1;
-                // decrement the reference of every field
-                counts.set(set, newVal);
-                // if that was the last reference we knew of
-                if (newVal <= 0) {
-                    targets.push(set);
-                    // remove the reference to the set function
-                    counts.delete(set);
-                }
-            }
-            // we do need to remove the set from the list
-            this.subscribers[fieldName] = this.getSubscribers(fieldName).filter(({ set }) => !targets.includes(set));
-        }
-    }
-    // this function is invoked by the cache when the garbage collector is ticking
-    onGcTick() {
-        const fields = Object.keys(this.fields)
-            .concat(Object.keys(this.listLinks))
-            .concat(Object.keys(this.recordLinks));
-        // any fields with no reference counts need to be decremented
-        for (const field of fields) {
-            // {value} has a key for every subscriber - can check for no subscribers by looking
-            // at the number of fields in the value
-            if (!this.referenceCounts[field] || this.referenceCounts[field].size === 0) {
-                // lower the current count by 1
-                const previousCount = this.lifetimes.get(field) || 0;
-                this.lifetimes.set(field, previousCount + 1);
-                // if the lifetime exceeds the cache's buffer size we should remove the field, linked record, or list
-                if (this.lifetimes.get(field) > this.cache.cacheBufferSize) {
-                    delete this.fields[field];
-                    delete this.recordLinks[field];
-                    delete this.recordLinks[field];
-                    // if we dont have any data left, delete the record from the cache
-                    if (Object.keys(this.fields).length === 0 &&
-                        Object.keys(this.recordLinks).length === 0 &&
-                        Object.keys(this.recordLinks).length === 0) {
-                        this.cache.internal.deleteID(this.id);
-                    }
-                }
-            }
-        }
-    }
-}