houdini 2.0.0-next.9 → 2.0.0

package/build/runtime/cache/gc.d.ts

@@ -1,10 +1,11 @@
-import type { Cache } from './cache';
+import type { Cache } from './index.js';
 export declare class GarbageCollector {
     cache: Cache;
     private lifetimes;
     get cacheBufferSize(): number;
     constructor(cache: Cache);
     reset(): void;
+    delete(id: string): void;
     resetLifetime(id: string, field: string): void;
     tick(): void;
 }

package/build/{runtime-esm → runtime}/cache/gc.js

@@ -11,6 +11,9 @@ class GarbageCollector {
   reset() {
     this.lifetimes.clear();
   }
+  delete(id) {
+    this.lifetimes.delete(id);
+  }
   resetLifetime(id, field) {
     if (!this.lifetimes.get(id)) {
       this.lifetimes.set(id, /* @__PURE__ */ new Map());
@@ -22,7 +25,7 @@ class GarbageCollector {
     const config_max_time = this.cache._internal_unstable.config.defaultLifetime;
     for (const [id, fieldMap] of this.lifetimes.entries()) {
       for (const [field, lifetime] of fieldMap.entries()) {
-        if (this.cache._internal_unstable.subscriptions.get(id, field).length > 0) {
+        if (this.cache._internal_unstable.subscriptions.get(id, field).length > 0 || this.cache._internal_unstable.subscriptions.getMaskedParents(id, field).length > 0) {
           continue;
         }
         fieldMap.set(field, lifetime + 1);

package/build/runtime/cache/index.d.ts

@@ -1,3 +1,173 @@
-import { Cache } from './cache';
-declare const _default: Cache;
-export default _default;
+import type { ConfigFile } from 'houdini';
+import type { GraphQLObject, GraphQLValue, NestedList, SubscriptionSelection, SubscriptionSpec, ValueMap, ValueNode } from '../types.js';
+import { GarbageCollector } from './gc.js';
+import type { ListCollection } from './lists.js';
+import { ListManager } from './lists.js';
+import { StaleManager } from './staleManager.js';
+import type { Layer, LayerID } from './storage.js';
+import { InMemoryStorage } from './storage.js';
+import { InMemorySubscriptions } from './subscription.js';
+export declare class Cache {
+    #private;
+    _internal_unstable: CacheInternal;
+    constructor({ disabled, componentCache, createComponent, ...config }?: ConfigFile & {
+        disabled?: boolean;
+        componentCache?: Record<string, any>;
+        createComponent?: (comp: any, prop: Record<string, any>) => any;
+    });
+    write({ layer: layerID, notifySubscribers, ...args }: {
+        data: {
+            [key: string]: GraphQLValue;
+        };
+        selection: SubscriptionSelection;
+        variables?: {};
+        parent?: string;
+        layer?: LayerID | null;
+        applyUpdates?: string[];
+        notifySubscribers?: SubscriptionSpec[];
+        forceNotify?: boolean;
+        forceStale?: boolean;
+    }): SubscriptionSpec[];
+    read(...args: Parameters<CacheInternal['getSelection']>): {
+        data: GraphQLObject | null;
+        partial: boolean;
+        stale: boolean;
+    };
+    subscribe(spec: SubscriptionSpec, variables?: {}): void;
+    unsubscribe(spec: SubscriptionSpec, variables?: {}): void;
+    list(name: string, parentID?: string, allLists?: boolean, skipMatches?: Set<string>): ListCollection;
+    registerKeyMap(source: string, mapped: string): void;
+    delete(id: string, layer?: Layer): void;
+    setConfig(config: ConfigFile): void;
+    markTypeStale(options?: {
+        type: string;
+        field?: string;
+        when?: {};
+    }): void;
+    refresh(id: string | string[]): void;
+    markRecordStale(id: string, options: {
+        field?: string;
+        when?: {};
+    }): void;
+    getFieldTime(id: string, field: string): number | null | undefined;
+    config(): ConfigFile;
+    serialize(): string;
+    hydrate(...args: Parameters<InMemoryStorage['hydrate']>): Layer | undefined;
+    clearLayer(layerID: Layer['id']): void;
+    reset(): void;
+    getEpoch(): number;
+}
+declare class CacheInternal {
+    disabled: boolean;
+    epoch: number;
+    _config?: ConfigFile;
+    storage: InMemoryStorage;
+    subscriptions: InMemorySubscriptions;
+    lists: ListManager;
+    cache: Cache;
+    lifetimes: GarbageCollector;
+    staleManager: StaleManager;
+    componentCache: Record<string, any>;
+    createComponent: (component: any, props: Record<string, any>) => any;
+    constructor({ storage, subscriptions, lists, cache, lifetimes, staleManager, disabled, config, componentCache, createComponent, }: {
+        storage: InMemoryStorage;
+        subscriptions: InMemorySubscriptions;
+        lists: ListManager;
+        cache: Cache;
+        lifetimes: GarbageCollector;
+        staleManager: StaleManager;
+        disabled: boolean;
+        config?: ConfigFile;
+        componentCache?: Record<string, any>;
+        createComponent: undefined | ((component: any, props: Record<string, any>) => any);
+    });
+    get config(): ConfigFile;
+    setConfig(config: ConfigFile): void;
+    writeSelection({ data, selection, variables, parent, applyUpdates, layer, toNotify, forceNotify, forceStale, }: {
+        data: {
+            [key: string]: GraphQLValue;
+        };
+        selection: SubscriptionSelection;
+        variables?: {
+            [key: string]: GraphQLValue;
+        };
+        parent?: string;
+        root?: string;
+        layer: Layer;
+        toNotify?: Set<SubscriptionSpec>;
+        applyUpdates?: string[];
+        forceNotify?: boolean;
+        forceStale?: boolean;
+    }): Set<SubscriptionSpec>;
+    getSelection({ selection, parent, variables, stepsFromConnection, ignoreMasking, fullCheck, loading: generateLoading, }: {
+        selection: SubscriptionSelection;
+        parent?: string;
+        variables?: {} | null;
+        stepsFromConnection?: number | null;
+        ignoreMasking?: boolean;
+        loading?: boolean;
+        fullCheck?: boolean;
+    }): {
+        data: GraphQLObject | null;
+        partial: boolean;
+        stale: boolean;
+        hasData: boolean;
+    };
+    id(type: string, data: {} | null): string | null;
+    id(type: string, id: string): string | null;
+    idFields(type: string): string[];
+    computeID(type: string, data: any): string;
+    isEmbedded(linkedType: string, value: GraphQLObject): boolean;
+    hydrateNestedList({ fields, variables, linkedList, stepsFromConnection, ignoreMasking, fullCheck, loading, nullable, }: {
+        fields: SubscriptionSelection;
+        nullable: boolean;
+        variables?: {} | null;
+        linkedList: NestedList;
+        stepsFromConnection: number | null;
+        ignoreMasking: boolean;
+        fullCheck?: boolean;
+        loading?: boolean;
+    }): {
+        data: NestedList<GraphQLValue>;
+        partial: boolean;
+        stale: boolean;
+        hasData: boolean;
+        cascadeNull: boolean;
+    };
+    extractNestedListIDs({ value, abstract, recordID, key, linkedType, fields, variables, applyUpdates, specs, layer, forceNotify, previousIDs, }: {
+        value: GraphQLValue[];
+        recordID: string;
+        key: string;
+        linkedType: string;
+        abstract: boolean;
+        variables: {};
+        specs: Set<SubscriptionSpec>;
+        applyUpdates?: string[];
+        fields: SubscriptionSelection;
+        layer: Layer;
+        forceNotify?: boolean;
+        previousIDs?: NestedList | null;
+    }): {
+        nestedIDs: NestedList;
+        newIDs: (string | null)[];
+    };
+    collectGarbage(): void;
+}
+export declare function evaluateVariables(variables: ValueMap, args: GraphQLObject): {
+    [k: string]: GraphQLValue;
+};
+export declare function variableValue(value: ValueNode, args: GraphQLObject): GraphQLValue;
+export declare function fragmentReference({ component, prop, }: {
+    component: {
+        name: string;
+    };
+    prop: string;
+}): any;
+export declare function defaultComponentField({ cache, component, loading, variables, parent, }: {
+    cache: Cache;
+    component: Required<Required<SubscriptionSelection>['fields'][string]>['component'];
+    loading?: boolean;
+    variables: Record<string, GraphQLValue> | undefined | null;
+    parent: string;
+}): (props: any) => any;
+export {};