houdini 2.0.0-next.9 → 2.0.1

package/build/runtime-cjs/cache/constants.d.ts

@@ -1 +0,0 @@
-export declare const rootID = "_ROOT_";

package/build/runtime-cjs/cache/constants.js

@@ -1,28 +0,0 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var constants_exports = {};
-__export(constants_exports, {
-  rootID: () => rootID
-});
-module.exports = __toCommonJS(constants_exports);
-const rootID = "_ROOT_";
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  rootID
-});

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

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

package/build/runtime-cjs/cache/gc.js

@@ -1,74 +0,0 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var gc_exports = {};
-__export(gc_exports, {
-  GarbageCollector: () => GarbageCollector
-});
-module.exports = __toCommonJS(gc_exports);
-class GarbageCollector {
-  cache;
-  lifetimes = /* @__PURE__ */ new Map();
-  // the number of ticks of the garbage collector that a piece of data will
-  get cacheBufferSize() {
-    return this.cache._internal_unstable.config.cacheBufferSize ?? 10;
-  }
-  constructor(cache) {
-    this.cache = cache;
-  }
-  reset() {
-    this.lifetimes.clear();
-  }
-  resetLifetime(id, field) {
-    if (!this.lifetimes.get(id)) {
-      this.lifetimes.set(id, /* @__PURE__ */ new Map());
-    }
-    this.lifetimes.get(id).set(field, 0);
-  }
-  tick() {
-    const dt_tick = Date.now().valueOf();
-    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) {
-          continue;
-        }
-        fieldMap.set(field, lifetime + 1);
-        if (fieldMap.get(field) > this.cacheBufferSize) {
-          this.cache._internal_unstable.storage.deleteField(id, field);
-          this.cache._internal_unstable.lists.deleteField(id, field);
-          fieldMap.delete(field);
-          if ([...fieldMap.keys()].length === 0) {
-            this.lifetimes.delete(id);
-          }
-          this.cache._internal_unstable.staleManager.delete(id, field);
-        }
-        if (config_max_time && config_max_time > 0) {
-          const dt_valueOf = this.cache.getFieldTime(id, field);
-          if (dt_valueOf && dt_tick - dt_valueOf > config_max_time) {
-            this.cache._internal_unstable.staleManager.markFieldStale(id, field);
-          }
-        }
-      }
-    }
-  }
-}
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  GarbageCollector
-});

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

@@ -1,3 +0,0 @@
-import { Cache } from './cache';
-declare const _default: Cache;
-export default _default;

package/build/runtime-cjs/cache/index.js

@@ -1,25 +0,0 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var cache_exports = {};
-__export(cache_exports, {
-  default: () => cache_default
-});
-module.exports = __toCommonJS(cache_exports);
-var import_cache = require("./cache");
-var cache_default = new import_cache.Cache();

package/build/runtime-cjs/cache/lists.d.ts

@@ -1,89 +0,0 @@
-import type { SubscriptionSelection, ListWhen, SubscriptionSpec } from '../lib/types';
-import type { Cache } from './cache';
-import type { Layer } from './storage';
-export declare class ListManager {
-    rootID: string;
-    cache: Cache;
-    constructor(cache: Cache, rootID: string);
-    lists: Map<string, Map<string, ListCollection>>;
-    private listsByField;
-    get(listName: string, id?: string, allLists?: boolean, skipMatches?: Set<string>): ListCollection | null;
-    getLists(listName: string, id?: string, allLists?: boolean): ListCollection | null | undefined;
-    remove(listName: string, id: string): void;
-    add(list: {
-        name: string;
-        connection: boolean;
-        recordID: SubscriptionSpec['parentID'];
-        recordType?: string;
-        key: string;
-        listType: string;
-        selection: SubscriptionSelection;
-        when?: ListWhen;
-        filters?: List['filters'];
-        abstract?: boolean;
-    }): void;
-    removeIDFromAllLists(id: string, layer?: Layer): boolean;
-    deleteField(parentID: string, field: string): void;
-    reset(): void;
-}
-export declare class List {
-    readonly recordID: string;
-    readonly recordType?: string;
-    readonly key: string;
-    readonly type: string;
-    private cache;
-    readonly selection: SubscriptionSelection;
-    private _when?;
-    private filters?;
-    readonly name: string;
-    private connection;
-    private manager;
-    private abstract?;
-    constructor({ name, recordID, recordType, key, listType, selection, when, filters, connection, manager, abstract, }: Parameters<ListManager['add']>[0] & {
-        manager: ListManager;
-    });
-    get fieldRef(): string;
-    when(when?: ListWhen): ListCollection;
-    append({ selection, data, variables, layer, }: {
-        selection: SubscriptionSelection;
-        data: {};
-        variables?: {};
-        layer?: Layer;
-    }): void;
-    prepend({ selection, data, variables, layer, }: {
-        selection: SubscriptionSelection;
-        data: {};
-        variables?: {};
-        layer?: Layer;
-    }): void;
-    addToList(selection: SubscriptionSelection, data: {}, variables: {} | undefined, where: 'first' | 'last', layer?: Layer): void;
-    removeID(id: string, variables?: {}, layer?: Layer): true | undefined;
-    remove(data: {}, variables?: {}, layer?: Layer): true | undefined;
-    listType(data: {
-        __typename?: string;
-    }): string;
-    validateWhen(when?: ListWhen): boolean;
-    toggleElement({ selection, data, variables, layer, where, }: {
-        selection: SubscriptionSelection;
-        data: {};
-        variables?: {};
-        layer?: Layer;
-        where: 'first' | 'last';
-    }): void;
-    [Symbol.iterator](): Generator<string, void, unknown>;
-}
-export declare class ListCollection {
-    lists: List[];
-    constructor(lists: List[]);
-    get selection(): SubscriptionSelection;
-    append(...args: Parameters<List['append']>): void;
-    prepend(...args: Parameters<List['prepend']>): void;
-    addToList(...args: Parameters<List['addToList']>): void;
-    removeID(...args: Parameters<List['removeID']>): boolean;
-    remove(...args: Parameters<List['remove']>): void;
-    toggleElement(...args: Parameters<List['toggleElement']>): void;
-    when(when?: ListWhen): ListCollection;
-    includes(key: string): boolean;
-    deleteListWithKey(key: string): List[];
-    [Symbol.iterator](): Generator<string, void, unknown>;
-}

package/build/runtime-cjs/cache/lists.js

@@ -1,467 +0,0 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var lists_exports = {};
-__export(lists_exports, {
-  List: () => List,
-  ListCollection: () => ListCollection,
-  ListManager: () => ListManager
-});
-module.exports = __toCommonJS(lists_exports);
-var import_flatten = require("../lib/flatten");
-var import_stuff = require("./stuff");
-class ListManager {
-  rootID;
-  cache;
-  constructor(cache, rootID2) {
-    this.rootID = rootID2;
-    this.cache = cache;
-  }
-  // associate list names with the handler that wraps the list
-  lists = /* @__PURE__ */ new Map();
-  listsByField = /* @__PURE__ */ new Map();
-  get(listName, id, allLists, skipMatches) {
-    const lists = this.getLists(listName, id, allLists);
-    if (!lists) {
-      return null;
-    }
-    if (skipMatches) {
-      return new ListCollection(lists.lists.filter((list) => !skipMatches.has(list.fieldRef)));
-    } else {
-      return lists;
-    }
-  }
-  getLists(listName, id, allLists) {
-    const matches = this.lists.get(listName);
-    if (!matches || matches.size === 0) {
-      return null;
-    }
-    if (allLists) {
-      return new ListCollection(
-        Array.from(matches, ([key, value]) => [...value.lists]).flat()
-      );
-    }
-    const head = [...matches.values()][0];
-    const { recordType } = head.lists[0];
-    const parentID = id ? this.cache._internal_unstable.id(recordType || "", id) : this.rootID;
-    if (matches?.size === 1) {
-      if (!id) {
-        return head;
-      }
-      return parentID === Array.from(matches.keys())[0] ? head : null;
-    }
-    if (!id) {
-      console.error(
-        `Found multiple instances of "${listName}". Please provide one of @parentID or @allLists directives to help identify which list you want modify. For more information, visit this guide: https://www.houdinigraphql.com/api/graphql#parentidvalue-string `
-      );
-      return null;
-    }
-    return this.lists.get(listName)?.get(parentID);
-  }
-  remove(listName, id) {
-    this.lists.get(listName)?.delete(id || this.rootID);
-  }
-  add(list) {
-    if (!this.lists.has(list.name)) {
-      this.lists.set(list.name, /* @__PURE__ */ new Map());
-    }
-    const name = list.name;
-    const parentID = list.recordID || this.rootID;
-    if (this.lists.get(name)?.get(parentID)?.includes(list.key)) {
-      return;
-    }
-    if (!this.lists.has(name)) {
-      this.lists.set(name, /* @__PURE__ */ new Map());
-    }
-    if (!this.lists.get(name).has(parentID)) {
-      this.lists.get(name).set(parentID, new ListCollection([]));
-    }
-    if (!this.listsByField.has(parentID)) {
-      this.listsByField.set(parentID, /* @__PURE__ */ new Map());
-    }
-    if (!this.listsByField.get(parentID).has(list.key)) {
-      this.listsByField.get(parentID)?.set(list.key, []);
-    }
-    const handler = new List({ ...list, manager: this });
-    this.lists.get(list.name).get(parentID).lists.push(handler);
-    this.listsByField.get(parentID).get(list.key).push(handler);
-  }
-  removeIDFromAllLists(id, layer) {
-    let removed = false;
-    for (const fieldMap of this.lists.values()) {
-      for (const list of fieldMap.values()) {
-        if (list.removeID(id, void 0, layer)) {
-          removed = true;
-        }
-      }
-    }
-    return removed;
-  }
-  deleteField(parentID, field) {
-    if (!this.listsByField.get(parentID)?.has(field)) {
-      return;
-    }
-    for (const list of this.listsByField.get(parentID).get(field)) {
-      this.lists.get(list.name)?.get(list.recordID)?.deleteListWithKey(field);
-      if (this.lists.get(list.name)?.get(list.recordID)?.lists.length === 0) {
-        this.lists.get(list.name)?.delete(list.recordID);
-      }
-    }
-    this.listsByField.get(parentID).delete(field);
-  }
-  reset() {
-    this.lists.clear();
-    this.listsByField.clear();
-  }
-}
-class List {
-  recordID;
-  recordType;
-  key;
-  type;
-  cache;
-  selection;
-  _when;
-  filters;
-  name;
-  connection;
-  manager;
-  abstract;
-  constructor({
-    name,
-    recordID,
-    recordType,
-    key,
-    listType,
-    selection,
-    when,
-    filters,
-    connection,
-    manager,
-    abstract
-  }) {
-    this.recordID = recordID || import_stuff.rootID;
-    this.recordType = recordType;
-    this.key = key;
-    this.type = listType;
-    this.cache = manager.cache;
-    this.selection = selection;
-    this._when = when;
-    this.filters = filters;
-    this.name = name;
-    this.connection = connection;
-    this.manager = manager;
-    this.abstract = abstract;
-  }
-  get fieldRef() {
-    return `${this.recordID}.${this.key}`;
-  }
-  // looks for the collection of all of the lists in the cache that satisfies a when
-  // condition
-  when(when) {
-    return this.manager.lists.get(this.name).get(this.recordID).when(when);
-  }
-  append({
-    selection,
-    data,
-    variables = {},
-    layer
-  }) {
-    return this.addToList(selection, data, variables, "last", layer);
-  }
-  prepend({
-    selection,
-    data,
-    variables = {},
-    layer
-  }) {
-    return this.addToList(selection, data, variables, "first", layer);
-  }
-  addToList(selection, data, variables = {}, where, layer) {
-    const listType = this.listType(data);
-    const dataID = this.cache._internal_unstable.id(listType, data);
-    if (!this.validateWhen() || !dataID) {
-      return;
-    }
-    let insertSelection = selection;
-    let insertData = data;
-    if (this.connection) {
-      insertSelection = {
-        fields: {
-          newEntry: {
-            keyRaw: this.key,
-            type: "Connection",
-            selection: {
-              fields: {
-                edges: {
-                  keyRaw: "edges",
-                  type: "ConnectionEdge",
-                  updates: ["append", "prepend"],
-                  selection: {
-                    fields: {
-                      __typename: {
-                        keyRaw: "__typename",
-                        type: "String"
-                      },
-                      node: {
-                        type: listType,
-                        keyRaw: "node",
-                        selection: {
-                          ...selection,
-                          fields: {
-                            ...selection.fields,
-                            __typename: {
-                              keyRaw: "__typename",
-                              type: "String"
-                            }
-                          }
-                        }
-                      }
-                    }
-                  }
-                }
-              }
-            }
-          }
-        }
-      };
-      insertData = {
-        newEntry: {
-          edges: [
-            {
-              __typename: listType + "Edge",
-              node: {
-                ...data,
-                __typename: listType
-              }
-            }
-          ]
-        }
-      };
-    } else {
-      insertSelection = {
-        fields: {
-          newEntries: {
-            keyRaw: this.key,
-            type: listType,
-            updates: ["append", "prepend"],
-            selection: {
-              ...selection,
-              fields: {
-                ...selection.fields,
-                __typename: {
-                  keyRaw: "__typename",
-                  type: "String"
-                }
-              }
-            }
-          }
-        }
-      };
-      insertData = {
-        newEntries: [{ ...data, __typename: listType }]
-      };
-    }
-    this.cache.write({
-      selection: insertSelection,
-      data: insertData,
-      variables,
-      parent: this.recordID,
-      applyUpdates: [where === "first" ? "prepend" : "append"],
-      layer: layer?.id
-    });
-  }
-  removeID(id, variables = {}, layer) {
-    if (!this.validateWhen()) {
-      return;
-    }
-    let parentID = this.recordID;
-    let targetID = id;
-    let targetKey = this.key;
-    if (this.connection) {
-      const { value: embeddedConnection } = this.cache._internal_unstable.storage.get(
-        this.recordID,
-        this.key
-      );
-      if (!embeddedConnection) {
-        return;
-      }
-      const embeddedConnectionID = embeddedConnection;
-      const { value: edges } = this.cache._internal_unstable.storage.get(
-        embeddedConnectionID,
-        "edges"
-      );
-      for (const edge of (0, import_flatten.flatten)(edges) || []) {
-        if (!edge) {
-          continue;
-        }
-        const edgeID = edge;
-        const { value: nodeID } = this.cache._internal_unstable.storage.get(edgeID, "node");
-        if (!nodeID) {
-          continue;
-        }
-        if (nodeID === id) {
-          targetID = edgeID;
-        }
-      }
-      parentID = embeddedConnectionID;
-      targetKey = "edges";
-    }
-    let value = this.cache._internal_unstable.storage.get(parentID, targetKey).value;
-    if (!value || !value.includes(targetID)) {
-      return;
-    }
-    const subscribers = this.cache._internal_unstable.subscriptions.get(this.recordID, this.key);
-    this.cache._internal_unstable.subscriptions.remove(
-      targetID,
-      // if we are unsubscribing from a connection, the fields we care about
-      // are tucked away under edges
-      this.connection ? this.selection.fields.edges.selection : this.selection,
-      subscribers.map((sub) => sub[0]),
-      variables
-    );
-    this.cache._internal_unstable.storage.remove(parentID, targetKey, targetID, layer);
-    for (const [spec] of subscribers) {
-      spec.set(
-        this.cache._internal_unstable.getSelection({
-          parent: spec.parentID || this.manager.rootID,
-          selection: spec.selection,
-          variables: spec.variables?.() || {},
-          ignoreMasking: false
-        }).data
-      );
-    }
-    return true;
-  }
-  remove(data, variables = {}, layer) {
-    const targetID = this.cache._internal_unstable.id(this.listType(data), data);
-    if (!targetID) {
-      return;
-    }
-    return this.removeID(targetID, variables, layer);
-  }
-  listType(data) {
-    return data.__typename || this.type;
-  }
-  validateWhen(when) {
-    let filters = when || this._when;
-    let ok = true;
-    if (filters) {
-      const targets = this.filters;
-      if (filters.must && targets) {
-        ok = Object.entries(filters.must).reduce(
-          (prev, [key, value]) => Boolean(prev && targets[key] == value),
-          ok
-        );
-      }
-      if (filters.must_not) {
-        ok = !targets || Object.entries(filters.must_not).reduce(
-          (prev, [key, value]) => Boolean(prev && targets[key] != value),
-          ok
-        );
-      }
-    }
-    return ok;
-  }
-  toggleElement({
-    selection,
-    data,
-    variables = {},
-    layer,
-    where
-  }) {
-    if (!this.remove(data, variables, layer)) {
-      this.addToList(selection, data, variables, where, layer);
-    }
-  }
-  // iterating over the list handler should be the same as iterating over
-  // the underlying linked list
-  *[Symbol.iterator]() {
-    let entries = [];
-    let value = this.cache._internal_unstable.storage.get(this.recordID, this.key).value;
-    if (!this.connection) {
-      entries = (0, import_flatten.flatten)(value);
-    } else {
-      entries = this.cache._internal_unstable.storage.get(value, "edges").value;
-    }
-    for (let record of entries) {
-      yield record;
-    }
-  }
-}
-class ListCollection {
-  lists = [];
-  constructor(lists) {
-    this.lists = lists;
-  }
-  get selection() {
-    return this.lists[0].selection;
-  }
-  append(...args) {
-    this.lists.forEach((list) => list.append(...args));
-  }
-  prepend(...args) {
-    this.lists.forEach((list) => list.prepend(...args));
-  }
-  addToList(...args) {
-    this.lists.forEach((list) => list.addToList(...args));
-  }
-  removeID(...args) {
-    let removed = false;
-    this.lists.forEach((list) => {
-      if (list.removeID(...args)) {
-        removed = true;
-      }
-    });
-    return removed;
-  }
-  remove(...args) {
-    this.lists.forEach((list) => list.remove(...args));
-  }
-  toggleElement(...args) {
-    this.lists.forEach((list) => list.toggleElement(...args));
-  }
-  when(when) {
-    return new ListCollection(
-      this.lists.filter((list) => {
-        return list.validateWhen(when);
-      })
-    );
-  }
-  includes(key) {
-    return !!this.lists.find((list) => list.key === key);
-  }
-  deleteListWithKey(key) {
-    return this.lists = this.lists.filter((list) => list.key !== key);
-  }
-  // iterating over the collection should be the same as iterating over
-  // the underlying list
-  *[Symbol.iterator]() {
-    for (let list of this.lists) {
-      for (const entry of list) {
-        yield entry;
-      }
-    }
-  }
-}
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  List,
-  ListCollection,
-  ListManager
-});