@isograph/react-disposable-state 0.0.0-main-c09c9dbf → 0.0.0-main-ae4fea0e

package/.turbo/turbo-compile-libs.log

@@ -1,11 +1,11 @@
-../..                                    |  WARN  Unsupported engine: wanted: {"node":"24.12.0"} (current: {"node":"v22.22.0","pnpm":"10.15.0"})
+../..                                    |  WARN  Unsupported engine: wanted: {"node":"24.12.0"} (current: {"node":"v24.20.0","pnpm":"10.15.0"})
 
-> @isograph/react-disposable-state@0.0.0-main-c09c9dbf compile-libs /home/runner/work/isograph/isograph/libs/isograph-react-disposable-state
+> @isograph/react-disposable-state@0.0.0-main-ae4fea0e compile-libs /home/runner/work/isograph/isograph/libs/isograph-react-disposable-state
 > tsdown
 
 ℹ tsdown v0.20.1 powered by rolldown v1.0.0-rc.1
 ℹ config file: /home/runner/work/isograph/isograph/tsdown.config.ts 
-(node:2724) [MODULE_TYPELESS_PACKAGE_JSON] Warning: Module type of file:///home/runner/work/isograph/isograph/tsdown.config.ts?no-cache=56ad6398-1bb3-432a-a57f-fa1164625a3d is not specified and it doesn't parse as CommonJS.
+(node:2799) [MODULE_TYPELESS_PACKAGE_JSON] Warning: Module type of file:///home/runner/work/isograph/isograph/tsdown.config.ts?no-cache=faf0b459-e85c-4dab-8fb5-f265432db97d is not specified and it doesn't parse as CommonJS.
 Reparsing as ES module because module syntax was detected. This incurs a performance overhead.
 To eliminate this warning, add "type": "module" to /home/runner/work/isograph/isograph/package.json.
 (Use `node --trace-warnings ...` to show where the warning was created)

package/.turbo/turbo-tsc.log

@@ -1,5 +1,5 @@
-../..                                    |  WARN  Unsupported engine: wanted: {"node":"24.12.0"} (current: {"node":"v22.22.0","pnpm":"10.15.0"})
+../..                                    |  WARN  Unsupported engine: wanted: {"node":"24.12.0"} (current: {"node":"v24.20.0","pnpm":"10.15.0"})
 
-> @isograph/react-disposable-state@0.0.0-main-c09c9dbf tsc /home/runner/work/isograph/isograph/libs/isograph-react-disposable-state
+> @isograph/react-disposable-state@0.0.0-main-ae4fea0e tsc /home/runner/work/isograph/isograph/libs/isograph-react-disposable-state
 > tsc
 

package/dist/ParentCache.cjs

@@ -18,9 +18,10 @@ const require_CacheItem = require('./CacheItem.cjs');
 *   be called
 */
 var ParentCache = class {
-	constructor(factory) {
+	constructor(factory, options) {
 		this.__cacheItem = null;
 		this.__factory = factory;
+		this.__options = options;
 	}
 	/**
 	* This is called from useCachedResponsivePrecommitValue, when the parent cache is populated
@@ -41,7 +42,7 @@ var ParentCache = class {
 	__populateAndTemporaryRetain() {
 		const pair = require_CacheItem.createTemporarilyRetainedCacheItem(this.__factory, () => {
 			if (this.__cacheItem === pair[0]) this.empty();
-		});
+		}, this.__options);
 		const [cacheItem, disposeTemporaryRetain] = pair;
 		this.__cacheItem = cacheItem;
 		return [

package/dist/ParentCache.d.cts

@@ -1,4 +1,4 @@
-import { CacheItem } from "./CacheItem.cjs";
+import { CacheItem, CacheItemOptions } from "./CacheItem.cjs";
 import { CleanupFn, Factory, ItemCleanupPair } from "@isograph/disposable-types";
 
 //#region src/ParentCache.d.ts
@@ -21,7 +21,8 @@ import { CleanupFn, Factory, ItemCleanupPair } from "@isograph/disposable-types"
 declare class ParentCache<T> {
   private __cacheItem;
   private readonly __factory;
-  constructor(factory: Factory<T>);
+  private readonly __options;
+  constructor(factory: Factory<T>, options?: CacheItemOptions);
   /**
    * This is called from useCachedResponsivePrecommitValue, when the parent cache is populated
    * and a previous temporary retain has been disposed. This can occur in scenarios like:

package/dist/ParentCache.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"ParentCache.d.cts","names":[],"sources":["../src/ParentCache.ts"],"mappings":";;;;;;AA2BA;;;;;;;;;;;;;;cAAa,WAAA;EAAA,QACH,WAAA;EAAA,iBACS,SAAA;cAIL,OAAA,EAAS,OAAA,CAAQ,CAAA;;;;;;;;;;;EAc7B,8BAAA,CAAA,GAAkC,eAAA,CAAgB,CAAA;EAMlD,+BAAA,CAAA,IAAoC,SAAA,CAAU,CAAA,GAAI,CAAA,EAAG,SAAA;EAAA,QAM7C,4BAAA;EA4BR,KAAA,CAAA;EAAA,IAII,OAAA,CAAA,GAAW,OAAA,CAAQ,CAAA;EAIvB,OAAA,CAAA;AAAA"}
+{"version":3,"file":"ParentCache.d.cts","names":[],"sources":["../src/ParentCache.ts"],"mappings":";;;;;;AA0BA;;;;;;;;;;;;;;cAAa,WAAA;EAAA,QACH,WAAA;EAAA,iBACS,SAAA;EAAA,iBACA,SAAA;cAIL,OAAA,EAAS,OAAA,CAAQ,CAAA,GAAI,OAAA,GAAU,gBAAA;EAJ1B;;;;;;;;;;EAmBjB,8BAAA,CAAA,GAAkC,eAAA,CAAgB,CAAA;EAMlD,+BAAA,CAAA,IAAoC,SAAA,CAAU,CAAA,GAAI,CAAA,EAAG,SAAA;EAAA,QAM7C,4BAAA;EAgCR,KAAA,CAAA;EAAA,IAII,OAAA,CAAA,GAAW,OAAA,CAAQ,CAAA;EAIvB,OAAA,CAAA;AAAA"}

package/dist/ParentCache.d.mts

@@ -1,4 +1,4 @@
-import { CacheItem } from "./CacheItem.mjs";
+import { CacheItem, CacheItemOptions } from "./CacheItem.mjs";
 import { CleanupFn, Factory, ItemCleanupPair } from "@isograph/disposable-types";
 
 //#region src/ParentCache.d.ts
@@ -21,7 +21,8 @@ import { CleanupFn, Factory, ItemCleanupPair } from "@isograph/disposable-types"
 declare class ParentCache<T> {
   private __cacheItem;
   private readonly __factory;
-  constructor(factory: Factory<T>);
+  private readonly __options;
+  constructor(factory: Factory<T>, options?: CacheItemOptions);
   /**
    * This is called from useCachedResponsivePrecommitValue, when the parent cache is populated
    * and a previous temporary retain has been disposed. This can occur in scenarios like:

package/dist/ParentCache.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"ParentCache.d.mts","names":[],"sources":["../src/ParentCache.ts"],"mappings":";;;;;;AA2BA;;;;;;;;;;;;;;cAAa,WAAA;EAAA,QACH,WAAA;EAAA,iBACS,SAAA;cAIL,OAAA,EAAS,OAAA,CAAQ,CAAA;;;;;;;;;;;EAc7B,8BAAA,CAAA,GAAkC,eAAA,CAAgB,CAAA;EAMlD,+BAAA,CAAA,IAAoC,SAAA,CAAU,CAAA,GAAI,CAAA,EAAG,SAAA;EAAA,QAM7C,4BAAA;EA4BR,KAAA,CAAA;EAAA,IAII,OAAA,CAAA,GAAW,OAAA,CAAQ,CAAA;EAIvB,OAAA,CAAA;AAAA"}
+{"version":3,"file":"ParentCache.d.mts","names":[],"sources":["../src/ParentCache.ts"],"mappings":";;;;;;AA0BA;;;;;;;;;;;;;;cAAa,WAAA;EAAA,QACH,WAAA;EAAA,iBACS,SAAA;EAAA,iBACA,SAAA;cAIL,OAAA,EAAS,OAAA,CAAQ,CAAA,GAAI,OAAA,GAAU,gBAAA;EAJ1B;;;;;;;;;;EAmBjB,8BAAA,CAAA,GAAkC,eAAA,CAAgB,CAAA;EAMlD,+BAAA,CAAA,IAAoC,SAAA,CAAU,CAAA,GAAI,CAAA,EAAG,SAAA;EAAA,QAM7C,4BAAA;EAgCR,KAAA,CAAA;EAAA,IAII,OAAA,CAAA,GAAW,OAAA,CAAQ,CAAA;EAIvB,OAAA,CAAA;AAAA"}

package/dist/ParentCache.mjs

@@ -18,9 +18,10 @@ import { createTemporarilyRetainedCacheItem } from "./CacheItem.mjs";
 *   be called
 */
 var ParentCache = class {
-	constructor(factory) {
+	constructor(factory, options) {
 		this.__cacheItem = null;
 		this.__factory = factory;
+		this.__options = options;
 	}
 	/**
 	* This is called from useCachedResponsivePrecommitValue, when the parent cache is populated
@@ -41,7 +42,7 @@ var ParentCache = class {
 	__populateAndTemporaryRetain() {
 		const pair = createTemporarilyRetainedCacheItem(this.__factory, () => {
 			if (this.__cacheItem === pair[0]) this.empty();
-		});
+		}, this.__options);
 		const [cacheItem, disposeTemporaryRetain] = pair;
 		this.__cacheItem = cacheItem;
 		return [

package/dist/ParentCache.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"ParentCache.mjs","names":[],"sources":["../src/ParentCache.ts"],"sourcesContent":["import type {\n  CleanupFn,\n  Factory,\n  ItemCleanupPair,\n} from '@isograph/disposable-types';\nimport type { CacheItem } from './CacheItem';\nimport { createTemporarilyRetainedCacheItem } from './CacheItem';\n\n// TODO convert cache impl to a getter and setter and free functions\n// TODO accept options that get passed to CacheItem\n\n/**\n * ParentCache\n * - A ParentCache can be in two states: populated and unpopulated.\n * - A ParentCache holds a CacheItem, which can choose to remove itself from\n *   the parent ParentCache.\n * - If the ParentCache is populated, the CacheItem (i.e. this.__value) must be\n *   in the InParentCacheAndNotDisposed state, i.e. not disposed, so after we\n *   null-check this.__value, this.__value.getValue(), this.__value.temporaryRetain()\n *   and this.__value.permanentRetain() are safe to be called.\n *\n * - Though we do not do so, it is always safe to call parentCache.delete().\n *\n * Invariant:\n * - A parent cache at a given \"location\" (conceptually, an ID) should always\n *   be called\n */\nexport class ParentCache<T> {\n  private __cacheItem: CacheItem<T> | null = null;\n  private readonly __factory: Factory<T>;\n\n  // TODO pass an onEmpty function, which can e.g. remove this ParentCache\n  // from some parent object.\n  constructor(factory: Factory<T>) {\n    this.__factory = factory;\n  }\n\n  /**\n   * This is called from useCachedResponsivePrecommitValue, when the parent cache is populated\n   * and a previous temporary retain has been disposed. This can occur in scenarios like:\n   * - temporary retain A is created by component B rendering\n   * - temporary retain A expires, emptying the parent cache\n   * - another component renders, sharing the same parent cache, filling\n   *   by calling getOrPopulateAndTemporaryRetain\n   * - component B commits. We see that temporary retain A has been disposed,\n   *   and re-check the parent cache by calling this method.\n   */\n  getAndPermanentRetainIfPresent(): ItemCleanupPair<T> | null {\n    return this.__cacheItem != null\n      ? [this.__cacheItem.getValue(), this.__cacheItem.permanentRetain()]\n      : null;\n  }\n\n  getOrPopulateAndTemporaryRetain(): [CacheItem<T>, T, CleanupFn] {\n    return this.__cacheItem == null\n      ? this.__populateAndTemporaryRetain()\n      : temporaryRetain(this.__cacheItem);\n  }\n\n  private __populateAndTemporaryRetain(): [CacheItem<T>, T, CleanupFn] {\n    const pair: ItemCleanupPair<CacheItem<T>> =\n      createTemporarilyRetainedCacheItem(this.__factory, () => {\n        // We are doing this check because we don't want to remove the cache item\n        // if it is not the one that was created when the temporary retain was created.\n        //\n        // Consider the following scenario:\n        // - we populate the cache with CacheItem A,\n        // - then manually delete CacheItem A (e.g. to force a refetch)\n        // - then, we re-populate the parent cache with CacheItem B\n        // - then, the temporary retain of CacheItem A is disposed or expires.\n        //\n        // At this point, we don't want to delete CacheItem B from the cache.\n        //\n        // TODO consider what happens if items are === comparable to each other,\n        // e.g. the item is a number!\n        if (this.__cacheItem === pair[0]) {\n          this.empty();\n        }\n      });\n\n    // We deconstruct this here instead of at the definition site because otherwise,\n    // typescript thinks that cacheItem is any, because it's referenced in the closure.\n    const [cacheItem, disposeTemporaryRetain] = pair;\n    this.__cacheItem = cacheItem;\n    return [cacheItem, cacheItem.getValue(), disposeTemporaryRetain];\n  }\n\n  empty() {\n    this.__cacheItem = null;\n  }\n\n  get factory(): Factory<T> {\n    return this.__factory;\n  }\n\n  isEmpty(): boolean {\n    return this.__cacheItem == null;\n  }\n}\n\nfunction temporaryRetain<T>(value: CacheItem<T>): [CacheItem<T>, T, CleanupFn] {\n  return [value, value.getValue(), value.temporaryRetain()];\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;AA2BA,IAAa,cAAb,MAA4B;CAM1B,YAAY,SAAqB;qBALU;AAMzC,OAAK,YAAY;;;;;;;;;;;;CAanB,iCAA4D;AAC1D,SAAO,KAAK,eAAe,OACvB,CAAC,KAAK,YAAY,UAAU,EAAE,KAAK,YAAY,iBAAiB,CAAC,GACjE;;CAGN,kCAAgE;AAC9D,SAAO,KAAK,eAAe,OACvB,KAAK,8BAA8B,GACnC,gBAAgB,KAAK,YAAY;;CAGvC,AAAQ,+BAA6D;EACnE,MAAM,OACJ,mCAAmC,KAAK,iBAAiB;AAcvD,OAAI,KAAK,gBAAgB,KAAK,GAC5B,MAAK,OAAO;IAEd;EAIJ,MAAM,CAAC,WAAW,0BAA0B;AAC5C,OAAK,cAAc;AACnB,SAAO;GAAC;GAAW,UAAU,UAAU;GAAE;GAAuB;;CAGlE,QAAQ;AACN,OAAK,cAAc;;CAGrB,IAAI,UAAsB;AACxB,SAAO,KAAK;;CAGd,UAAmB;AACjB,SAAO,KAAK,eAAe;;;AAI/B,SAAS,gBAAmB,OAAmD;AAC7E,QAAO;EAAC;EAAO,MAAM,UAAU;EAAE,MAAM,iBAAiB;EAAC"}
+{"version":3,"file":"ParentCache.mjs","names":[],"sources":["../src/ParentCache.ts"],"sourcesContent":["import type {\n  CleanupFn,\n  Factory,\n  ItemCleanupPair,\n} from '@isograph/disposable-types';\nimport type { CacheItem, CacheItemOptions } from './CacheItem';\nimport { createTemporarilyRetainedCacheItem } from './CacheItem';\n\n// TODO convert cache impl to a getter and setter and free functions\n\n/**\n * ParentCache\n * - A ParentCache can be in two states: populated and unpopulated.\n * - A ParentCache holds a CacheItem, which can choose to remove itself from\n *   the parent ParentCache.\n * - If the ParentCache is populated, the CacheItem (i.e. this.__value) must be\n *   in the InParentCacheAndNotDisposed state, i.e. not disposed, so after we\n *   null-check this.__value, this.__value.getValue(), this.__value.temporaryRetain()\n *   and this.__value.permanentRetain() are safe to be called.\n *\n * - Though we do not do so, it is always safe to call parentCache.delete().\n *\n * Invariant:\n * - A parent cache at a given \"location\" (conceptually, an ID) should always\n *   be called\n */\nexport class ParentCache<T> {\n  private __cacheItem: CacheItem<T> | null = null;\n  private readonly __factory: Factory<T>;\n  private readonly __options: CacheItemOptions | void;\n\n  // TODO pass an onEmpty function, which can e.g. remove this ParentCache\n  // from some parent object.\n  constructor(factory: Factory<T>, options?: CacheItemOptions) {\n    this.__factory = factory;\n    this.__options = options;\n  }\n\n  /**\n   * This is called from useCachedResponsivePrecommitValue, when the parent cache is populated\n   * and a previous temporary retain has been disposed. This can occur in scenarios like:\n   * - temporary retain A is created by component B rendering\n   * - temporary retain A expires, emptying the parent cache\n   * - another component renders, sharing the same parent cache, filling\n   *   by calling getOrPopulateAndTemporaryRetain\n   * - component B commits. We see that temporary retain A has been disposed,\n   *   and re-check the parent cache by calling this method.\n   */\n  getAndPermanentRetainIfPresent(): ItemCleanupPair<T> | null {\n    return this.__cacheItem != null\n      ? [this.__cacheItem.getValue(), this.__cacheItem.permanentRetain()]\n      : null;\n  }\n\n  getOrPopulateAndTemporaryRetain(): [CacheItem<T>, T, CleanupFn] {\n    return this.__cacheItem == null\n      ? this.__populateAndTemporaryRetain()\n      : temporaryRetain(this.__cacheItem);\n  }\n\n  private __populateAndTemporaryRetain(): [CacheItem<T>, T, CleanupFn] {\n    const pair: ItemCleanupPair<CacheItem<T>> =\n      createTemporarilyRetainedCacheItem(\n        this.__factory,\n        () => {\n          // We are doing this check because we don't want to remove the cache item\n          // if it is not the one that was created when the temporary retain was created.\n          //\n          // Consider the following scenario:\n          // - we populate the cache with CacheItem A,\n          // - then manually delete CacheItem A (e.g. to force a refetch)\n          // - then, we re-populate the parent cache with CacheItem B\n          // - then, the temporary retain of CacheItem A is disposed or expires.\n          //\n          // At this point, we don't want to delete CacheItem B from the cache.\n          //\n          // TODO consider what happens if items are === comparable to each other,\n          // e.g. the item is a number!\n          if (this.__cacheItem === pair[0]) {\n            this.empty();\n          }\n        },\n        this.__options,\n      );\n\n    // We deconstruct this here instead of at the definition site because otherwise,\n    // typescript thinks that cacheItem is any, because it's referenced in the closure.\n    const [cacheItem, disposeTemporaryRetain] = pair;\n    this.__cacheItem = cacheItem;\n    return [cacheItem, cacheItem.getValue(), disposeTemporaryRetain];\n  }\n\n  empty() {\n    this.__cacheItem = null;\n  }\n\n  get factory(): Factory<T> {\n    return this.__factory;\n  }\n\n  isEmpty(): boolean {\n    return this.__cacheItem == null;\n  }\n}\n\nfunction temporaryRetain<T>(value: CacheItem<T>): [CacheItem<T>, T, CleanupFn] {\n  return [value, value.getValue(), value.temporaryRetain()];\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;AA0BA,IAAa,cAAb,MAA4B;CAO1B,YAAY,SAAqB,SAA4B;qBANlB;AAOzC,OAAK,YAAY;AACjB,OAAK,YAAY;;;;;;;;;;;;CAanB,iCAA4D;AAC1D,SAAO,KAAK,eAAe,OACvB,CAAC,KAAK,YAAY,UAAU,EAAE,KAAK,YAAY,iBAAiB,CAAC,GACjE;;CAGN,kCAAgE;AAC9D,SAAO,KAAK,eAAe,OACvB,KAAK,8BAA8B,GACnC,gBAAgB,KAAK,YAAY;;CAGvC,AAAQ,+BAA6D;EACnE,MAAM,OACJ,mCACE,KAAK,iBACC;AAcJ,OAAI,KAAK,gBAAgB,KAAK,GAC5B,MAAK,OAAO;KAGhB,KAAK,UACN;EAIH,MAAM,CAAC,WAAW,0BAA0B;AAC5C,OAAK,cAAc;AACnB,SAAO;GAAC;GAAW,UAAU,UAAU;GAAE;GAAuB;;CAGlE,QAAQ;AACN,OAAK,cAAc;;CAGrB,IAAI,UAAsB;AACxB,SAAO,KAAK;;CAGd,UAAmB;AACjB,SAAO,KAAK,eAAe;;;AAI/B,SAAS,gBAAmB,OAAmD;AAC7E,QAAO;EAAC;EAAO,MAAM,UAAU;EAAE,MAAM,iBAAiB;EAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@isograph/react-disposable-state",
-  "version": "0.0.0-main-c09c9dbf",
+  "version": "0.0.0-main-ae4fea0e",
   "description": "Primitives for managing disposable state in React",
   "homepage": "https://isograph.dev",
   "main": "./dist/index.cjs",
@@ -8,7 +8,7 @@
   "author": "Isograph Labs",
   "license": "MIT",
   "dependencies": {
-    "@isograph/disposable-types": "0.0.0-main-c09c9dbf"
+    "@isograph/disposable-types": "0.0.0-main-ae4fea0e"
   },
   "peerDependencies": {
     "react": "^18.0.0 || ^19.0.0"

package/src/ParentCache.ts

@@ -3,11 +3,10 @@ import type {
   Factory,
   ItemCleanupPair,
 } from '@isograph/disposable-types';
-import type { CacheItem } from './CacheItem';
+import type { CacheItem, CacheItemOptions } from './CacheItem';
 import { createTemporarilyRetainedCacheItem } from './CacheItem';
 
 // TODO convert cache impl to a getter and setter and free functions
-// TODO accept options that get passed to CacheItem
 
 /**
  * ParentCache
@@ -28,11 +27,13 @@ import { createTemporarilyRetainedCacheItem } from './CacheItem';
 export class ParentCache<T> {
   private __cacheItem: CacheItem<T> | null = null;
   private readonly __factory: Factory<T>;
+  private readonly __options: CacheItemOptions | void;
 
   // TODO pass an onEmpty function, which can e.g. remove this ParentCache
   // from some parent object.
-  constructor(factory: Factory<T>) {
+  constructor(factory: Factory<T>, options?: CacheItemOptions) {
     this.__factory = factory;
+    this.__options = options;
   }
 
   /**
@@ -59,24 +60,28 @@ export class ParentCache<T> {
 
   private __populateAndTemporaryRetain(): [CacheItem<T>, T, CleanupFn] {
     const pair: ItemCleanupPair<CacheItem<T>> =
-      createTemporarilyRetainedCacheItem(this.__factory, () => {
-        // We are doing this check because we don't want to remove the cache item
-        // if it is not the one that was created when the temporary retain was created.
-        //
-        // Consider the following scenario:
-        // - we populate the cache with CacheItem A,
-        // - then manually delete CacheItem A (e.g. to force a refetch)
-        // - then, we re-populate the parent cache with CacheItem B
-        // - then, the temporary retain of CacheItem A is disposed or expires.
-        //
-        // At this point, we don't want to delete CacheItem B from the cache.
-        //
-        // TODO consider what happens if items are === comparable to each other,
-        // e.g. the item is a number!
-        if (this.__cacheItem === pair[0]) {
-          this.empty();
-        }
-      });
+      createTemporarilyRetainedCacheItem(
+        this.__factory,
+        () => {
+          // We are doing this check because we don't want to remove the cache item
+          // if it is not the one that was created when the temporary retain was created.
+          //
+          // Consider the following scenario:
+          // - we populate the cache with CacheItem A,
+          // - then manually delete CacheItem A (e.g. to force a refetch)
+          // - then, we re-populate the parent cache with CacheItem B
+          // - then, the temporary retain of CacheItem A is disposed or expires.
+          //
+          // At this point, we don't want to delete CacheItem B from the cache.
+          //
+          // TODO consider what happens if items are === comparable to each other,
+          // e.g. the item is a number!
+          if (this.__cacheItem === pair[0]) {
+            this.empty();
+          }
+        },
+        this.__options,
+      );
 
     // We deconstruct this here instead of at the definition site because otherwise,
     // typescript thinks that cacheItem is any, because it's referenced in the closure.