@isograph/reference-counted-pointer 0.5.0 → 0.5.1

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

@@ -1,5 +1,12 @@
 ../..                                    |  WARN  Unsupported engine: wanted: {"node":"22.9.0"} (current: {"node":"v22.21.1","pnpm":"10.15.0"})
 
-> @isograph/reference-counted-pointer@0.5.0 compile-libs /home/runner/work/isograph/isograph/libs/isograph-reference-counted-pointer
-> rimraf dist && tsc -p tsconfig.pkg.json
+> @isograph/reference-counted-pointer@0.5.1 compile-libs /home/runner/work/isograph/isograph/libs/isograph-reference-counted-pointer
+> tsdown
 
+ℹ tsdown v0.15.10 powered by rolldown v1.0.0-beta.44
+ℹ Using tsdown config: /home/runner/work/isograph/isograph/tsdown.config.ts
+(node:2982) [MODULE_TYPELESS_PACKAGE_JSON] Warning: Module type of file:///home/runner/work/isograph/isograph/tsdown.config.ts 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)
+ℹ Build start

package/dist/createReferenceCountedPointer.d.mts

@@ -0,0 +1,39 @@
+import { ItemCleanupPair } from "@isograph/disposable-types";
+
+//#region src/createReferenceCountedPointer.d.ts
+
+/**
+ * Create an undisposed reference-counted pointer guarding a given item.
+ *
+ * Once all reference-counted pointers guarding a given item have been
+ * disposed, the underlying item will be disposed.
+ *
+ * Additional reference-counted pointers guarding the same item can be
+ * created by calling cloneIfNotDisposed().
+ *
+ * ## Structural sharing
+ *
+ * Reference counted pointers enable reusing disposable items between
+ * application states, so-called structural sharing.
+ *
+ * If state 1 contains a reference counted pointer to an item, in order
+ * to transition to state 2, one would first create an additional
+ * reference-counted pointer by calling cloneIfNotDisposed, transition
+ * to state 2, then clean up state 1 by disposing of its reference-
+ * counted pointers. In this transition, at no time were there zero
+ * undisposed reference countend pointers to the disposable item, so it
+ * was never disposed, and we could reuse it between states.
+ */
+declare function createReferenceCountedPointer<T>(pair: ItemCleanupPair<T>): ItemCleanupPair<ReferenceCountedPointer<T>>;
+interface ReferenceCountedPointer<T> {
+  isDisposed(): boolean;
+  /**
+   * Safety: the item returned here is valid for use only as long as the reference
+   * counted pointer is not disposed.
+   */
+  getItemIfNotDisposed(): T | null;
+  cloneIfNotDisposed(): ItemCleanupPair<ReferenceCountedPointer<T>> | null;
+}
+//#endregion
+export { ReferenceCountedPointer, createReferenceCountedPointer };
+//# sourceMappingURL=createReferenceCountedPointer.d.mts.map

package/dist/createReferenceCountedPointer.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createReferenceCountedPointer.d.mts","names":[],"sources":["../src/createReferenceCountedPointer.ts"],"sourcesContent":[],"mappings":";;;;;;AA0BA;;;;;;;AAQA;;;;;;;;;;;;;iBARgB,uCACR,gBAAgB,KACrB,gBAAgB,wBAAwB;UAM1B;;;;;;0BAMS;wBACF,gBAAgB,wBAAwB"}

package/dist/createReferenceCountedPointer.d.ts

@@ -1,4 +1,7 @@
-import type { ItemCleanupPair } from '@isograph/disposable-types';
+import { ItemCleanupPair } from "@isograph/disposable-types";
+
+//#region src/createReferenceCountedPointer.d.ts
+
 /**
  * Create an undisposed reference-counted pointer guarding a given item.
  *
@@ -21,14 +24,16 @@ import type { ItemCleanupPair } from '@isograph/disposable-types';
  * undisposed reference countend pointers to the disposable item, so it
  * was never disposed, and we could reuse it between states.
  */
-export declare function createReferenceCountedPointer<T>(pair: ItemCleanupPair<T>): ItemCleanupPair<ReferenceCountedPointer<T>>;
-export interface ReferenceCountedPointer<T> {
-    isDisposed(): boolean;
-    /**
-     * Safety: the item returned here is valid for use only as long as the reference
-     * counted pointer is not disposed.
-     */
-    getItemIfNotDisposed(): T | null;
-    cloneIfNotDisposed(): ItemCleanupPair<ReferenceCountedPointer<T>> | null;
+declare function createReferenceCountedPointer<T>(pair: ItemCleanupPair<T>): ItemCleanupPair<ReferenceCountedPointer<T>>;
+interface ReferenceCountedPointer<T> {
+  isDisposed(): boolean;
+  /**
+   * Safety: the item returned here is valid for use only as long as the reference
+   * counted pointer is not disposed.
+   */
+  getItemIfNotDisposed(): T | null;
+  cloneIfNotDisposed(): ItemCleanupPair<ReferenceCountedPointer<T>> | null;
 }
+//#endregion
+export { ReferenceCountedPointer, createReferenceCountedPointer };
 //# sourceMappingURL=createReferenceCountedPointer.d.ts.map

package/dist/createReferenceCountedPointer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"createReferenceCountedPointer.d.ts","sourceRoot":"","sources":["../src/createReferenceCountedPointer.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAa,eAAe,EAAE,MAAM,4BAA4B,CAAC;AAI7E;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,6BAA6B,CAAC,CAAC,EAC7C,IAAI,EAAE,eAAe,CAAC,CAAC,CAAC,GACvB,eAAe,CAAC,uBAAuB,CAAC,CAAC,CAAC,CAAC,CAI7C;AAED,MAAM,WAAW,uBAAuB,CAAC,CAAC;IACxC,UAAU,IAAI,OAAO,CAAC;IACtB;;;OAGG;IACH,oBAAoB,IAAI,CAAC,GAAG,IAAI,CAAC;IACjC,kBAAkB,IAAI,eAAe,CAAC,uBAAuB,CAAC,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC;CAC1E"}
+{"version":3,"file":"createReferenceCountedPointer.d.ts","names":[],"sources":["../src/createReferenceCountedPointer.ts"],"sourcesContent":[],"mappings":";;;;;;AA0BA;;;;;;;AAQA;;;;;;;;;;;;;iBARgB,uCACR,gBAAgB,KACrB,gBAAgB,wBAAwB;UAM1B;;;;;;0BAMS;wBACF,gBAAgB,wBAAwB"}

package/dist/createReferenceCountedPointer.js

@@ -1,106 +1,84 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createReferenceCountedPointer = createReferenceCountedPointer;
-// TODO cloneIfNotDisposed should also return the underlying item
+
+//#region src/createReferenceCountedPointer.ts
 /**
- * Create an undisposed reference-counted pointer guarding a given item.
- *
- * Once all reference-counted pointers guarding a given item have been
- * disposed, the underlying item will be disposed.
- *
- * Additional reference-counted pointers guarding the same item can be
- * created by calling cloneIfNotDisposed().
- *
- * ## Structural sharing
- *
- * Reference counted pointers enable reusing disposable items between
- * application states, so-called structural sharing.
- *
- * If state 1 contains a reference counted pointer to an item, in order
- * to transition to state 2, one would first create an additional
- * reference-counted pointer by calling cloneIfNotDisposed, transition
- * to state 2, then clean up state 1 by disposing of its reference-
- * counted pointers. In this transition, at no time were there zero
- * undisposed reference countend pointers to the disposable item, so it
- * was never disposed, and we could reuse it between states.
- */
+* Create an undisposed reference-counted pointer guarding a given item.
+*
+* Once all reference-counted pointers guarding a given item have been
+* disposed, the underlying item will be disposed.
+*
+* Additional reference-counted pointers guarding the same item can be
+* created by calling cloneIfNotDisposed().
+*
+* ## Structural sharing
+*
+* Reference counted pointers enable reusing disposable items between
+* application states, so-called structural sharing.
+*
+* If state 1 contains a reference counted pointer to an item, in order
+* to transition to state 2, one would first create an additional
+* reference-counted pointer by calling cloneIfNotDisposed, transition
+* to state 2, then clean up state 1 by disposing of its reference-
+* counted pointers. In this transition, at no time were there zero
+* undisposed reference countend pointers to the disposable item, so it
+* was never disposed, and we could reuse it between states.
+*/
 function createReferenceCountedPointer(pair) {
-    const originalReferenceCountedPointer = new RefCounter(pair);
-    return originalReferenceCountedPointer.retainIfNotDisposed();
-}
-// N.B. this could implement ReferenceCountedPointer<T>, but it would not be correct to use it
-// as such, since it does not have an associated dispose function that can be called.
-//
-// Note that there is no way, and should be no way, to determine whether the underlying item
-// has been disposed, let alone force it to be disposed! If you need that, you need to keep track
-// of all calls to retainIfNotDisposed.
-class RefCounter {
-    /**
-     * Private. Do not expose this class directly, as this contructor creates a ReferenceCountedPointer
-     * in an invalid state. We must immediately, after creation, call retainIfNotDisposed().
-     */
-    constructor([item, dispose]) {
-        this.__state = {
-            item,
-            dispose,
-            activeReferenceCount: 0,
-        };
-    }
-    getIfNotDisposed() {
-        return this.__state === null ? null : this.__state.item;
-    }
-    retainIfNotDisposed() {
-        if (this.__state !== null) {
-            this.__state.activeReferenceCount++;
-            const activeReference = new ActiveReference(this);
-            let disposed = false;
-            const dispose = () => {
-                if (disposed) {
-                    throw new Error('Do not dispose an already-disposed ActiveReference.');
-                }
-                disposed = true;
-                if (activeReference.__original === null) {
-                    throw new Error('Attempted to dispose an active reference, but it was already disposed. ' +
-                        'This indicates a bug in reference-counted-pointer.');
-                }
-                activeReference.__original = null;
-                if (this.__state === null) {
-                    throw new Error('Attempted to dispose, but the underlying reference counted pointer was disposed. ' +
-                        'This indicates a bug in reference-counted-pointer.');
-                }
-                this.__state.activeReferenceCount--;
-                this.__maybeDispose();
-            };
-            return [activeReference, dispose];
-        }
-        else {
-            return null;
-        }
-    }
-    __maybeDispose() {
-        if (this.__state === null) {
-            throw new Error('__maybeDispose was called, but the reference counted pointer was disposed. ' +
-                'This indicates a bug in reference-counted-pointer.');
-        }
-        if (this.__state.activeReferenceCount === 0) {
-            this.__state.dispose();
-            this.__state = null;
-        }
-    }
-}
-class ActiveReference {
-    constructor(original) {
-        this.__original = original;
-    }
-    isDisposed() {
-        return this.__original === null;
-    }
-    cloneIfNotDisposed() {
-        var _a, _b;
-        return (_b = (_a = this.__original) === null || _a === void 0 ? void 0 : _a.retainIfNotDisposed()) !== null && _b !== void 0 ? _b : null;
-    }
-    getItemIfNotDisposed() {
-        var _a, _b;
-        return (_b = (_a = this.__original) === null || _a === void 0 ? void 0 : _a.getIfNotDisposed()) !== null && _b !== void 0 ? _b : null;
-    }
+	return new RefCounter(pair).retainIfNotDisposed();
 }
+var RefCounter = class {
+	/**
+	* Private. Do not expose this class directly, as this contructor creates a ReferenceCountedPointer
+	* in an invalid state. We must immediately, after creation, call retainIfNotDisposed().
+	*/
+	constructor([item, dispose]) {
+		this.__state = {
+			item,
+			dispose,
+			activeReferenceCount: 0
+		};
+	}
+	getIfNotDisposed() {
+		return this.__state == null ? null : this.__state.item;
+	}
+	retainIfNotDisposed() {
+		if (this.__state != null) {
+			this.__state.activeReferenceCount++;
+			const activeReference = new ActiveReference(this);
+			let disposed = false;
+			const dispose = () => {
+				if (disposed) throw new Error("Do not dispose an already-disposed ActiveReference.");
+				disposed = true;
+				if (activeReference.__original == null) throw new Error("Attempted to dispose an active reference, but it was already disposed. This indicates a bug in reference-counted-pointer.");
+				activeReference.__original = null;
+				if (this.__state == null) throw new Error("Attempted to dispose, but the underlying reference counted pointer was disposed. This indicates a bug in reference-counted-pointer.");
+				this.__state.activeReferenceCount--;
+				this.__maybeDispose();
+			};
+			return [activeReference, dispose];
+		} else return null;
+	}
+	__maybeDispose() {
+		if (this.__state == null) throw new Error("__maybeDispose was called, but the reference counted pointer was disposed. This indicates a bug in reference-counted-pointer.");
+		if (this.__state.activeReferenceCount === 0) {
+			this.__state.dispose();
+			this.__state = null;
+		}
+	}
+};
+var ActiveReference = class {
+	constructor(original) {
+		this.__original = original;
+	}
+	isDisposed() {
+		return this.__original == null;
+	}
+	cloneIfNotDisposed() {
+		return this.__original?.retainIfNotDisposed() ?? null;
+	}
+	getItemIfNotDisposed() {
+		return this.__original?.getIfNotDisposed() ?? null;
+	}
+};
+
+//#endregion
+exports.createReferenceCountedPointer = createReferenceCountedPointer;

package/dist/createReferenceCountedPointer.mjs

@@ -0,0 +1,84 @@
+//#region src/createReferenceCountedPointer.ts
+/**
+* Create an undisposed reference-counted pointer guarding a given item.
+*
+* Once all reference-counted pointers guarding a given item have been
+* disposed, the underlying item will be disposed.
+*
+* Additional reference-counted pointers guarding the same item can be
+* created by calling cloneIfNotDisposed().
+*
+* ## Structural sharing
+*
+* Reference counted pointers enable reusing disposable items between
+* application states, so-called structural sharing.
+*
+* If state 1 contains a reference counted pointer to an item, in order
+* to transition to state 2, one would first create an additional
+* reference-counted pointer by calling cloneIfNotDisposed, transition
+* to state 2, then clean up state 1 by disposing of its reference-
+* counted pointers. In this transition, at no time were there zero
+* undisposed reference countend pointers to the disposable item, so it
+* was never disposed, and we could reuse it between states.
+*/
+function createReferenceCountedPointer(pair) {
+	return new RefCounter(pair).retainIfNotDisposed();
+}
+var RefCounter = class {
+	/**
+	* Private. Do not expose this class directly, as this contructor creates a ReferenceCountedPointer
+	* in an invalid state. We must immediately, after creation, call retainIfNotDisposed().
+	*/
+	constructor([item, dispose]) {
+		this.__state = {
+			item,
+			dispose,
+			activeReferenceCount: 0
+		};
+	}
+	getIfNotDisposed() {
+		return this.__state == null ? null : this.__state.item;
+	}
+	retainIfNotDisposed() {
+		if (this.__state != null) {
+			this.__state.activeReferenceCount++;
+			const activeReference = new ActiveReference(this);
+			let disposed = false;
+			const dispose = () => {
+				if (disposed) throw new Error("Do not dispose an already-disposed ActiveReference.");
+				disposed = true;
+				if (activeReference.__original == null) throw new Error("Attempted to dispose an active reference, but it was already disposed. This indicates a bug in reference-counted-pointer.");
+				activeReference.__original = null;
+				if (this.__state == null) throw new Error("Attempted to dispose, but the underlying reference counted pointer was disposed. This indicates a bug in reference-counted-pointer.");
+				this.__state.activeReferenceCount--;
+				this.__maybeDispose();
+			};
+			return [activeReference, dispose];
+		} else return null;
+	}
+	__maybeDispose() {
+		if (this.__state == null) throw new Error("__maybeDispose was called, but the reference counted pointer was disposed. This indicates a bug in reference-counted-pointer.");
+		if (this.__state.activeReferenceCount === 0) {
+			this.__state.dispose();
+			this.__state = null;
+		}
+	}
+};
+var ActiveReference = class {
+	constructor(original) {
+		this.__original = original;
+	}
+	isDisposed() {
+		return this.__original == null;
+	}
+	cloneIfNotDisposed() {
+		return this.__original?.retainIfNotDisposed() ?? null;
+	}
+	getItemIfNotDisposed() {
+		return this.__original?.getIfNotDisposed() ?? null;
+	}
+};
+
+//#endregion
+export { createReferenceCountedPointer };
+//# sourceMappingURL=createReferenceCountedPointer.mjs.map

package/dist/createReferenceCountedPointer.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"createReferenceCountedPointer.mjs","names":[],"sources":["../src/createReferenceCountedPointer.ts"],"sourcesContent":["import type { CleanupFn, ItemCleanupPair } from '@isograph/disposable-types';\n\n// TODO cloneIfNotDisposed should also return the underlying item\n\n/**\n * Create an undisposed reference-counted pointer guarding a given item.\n *\n * Once all reference-counted pointers guarding a given item have been\n * disposed, the underlying item will be disposed.\n *\n * Additional reference-counted pointers guarding the same item can be\n * created by calling cloneIfNotDisposed().\n *\n * ## Structural sharing\n *\n * Reference counted pointers enable reusing disposable items between\n * application states, so-called structural sharing.\n *\n * If state 1 contains a reference counted pointer to an item, in order\n * to transition to state 2, one would first create an additional\n * reference-counted pointer by calling cloneIfNotDisposed, transition\n * to state 2, then clean up state 1 by disposing of its reference-\n * counted pointers. In this transition, at no time were there zero\n * undisposed reference countend pointers to the disposable item, so it\n * was never disposed, and we could reuse it between states.\n */\nexport function createReferenceCountedPointer<T>(\n  pair: ItemCleanupPair<T>,\n): ItemCleanupPair<ReferenceCountedPointer<T>> {\n  const originalReferenceCountedPointer = new RefCounter(pair);\n\n  return originalReferenceCountedPointer.retainIfNotDisposed()!;\n}\n\nexport interface ReferenceCountedPointer<T> {\n  isDisposed(): boolean;\n  /**\n   * Safety: the item returned here is valid for use only as long as the reference\n   * counted pointer is not disposed.\n   */\n  getItemIfNotDisposed(): T | null;\n  cloneIfNotDisposed(): ItemCleanupPair<ReferenceCountedPointer<T>> | null;\n}\n\ntype RefCountState<T> = {\n  item: T;\n  dispose: CleanupFn;\n  // Invariant: >0\n  activeReferenceCount: number;\n};\n\n// N.B. this could implement ReferenceCountedPointer<T>, but it would not be correct to use it\n// as such, since it does not have an associated dispose function that can be called.\n//\n// Note that there is no way, and should be no way, to determine whether the underlying item\n// has been disposed, let alone force it to be disposed! If you need that, you need to keep track\n// of all calls to retainIfNotDisposed.\nclass RefCounter<T> {\n  private __state: RefCountState<T> | null;\n\n  /**\n   * Private. Do not expose this class directly, as this contructor creates a ReferenceCountedPointer\n   * in an invalid state. We must immediately, after creation, call retainIfNotDisposed().\n   */\n  constructor([item, dispose]: ItemCleanupPair<T>) {\n    this.__state = {\n      item,\n      dispose,\n      activeReferenceCount: 0,\n    };\n  }\n\n  getIfNotDisposed(): T | null {\n    return this.__state == null ? null : this.__state.item;\n  }\n\n  retainIfNotDisposed(): ItemCleanupPair<ReferenceCountedPointer<T>> | null {\n    if (this.__state != null) {\n      this.__state.activeReferenceCount++;\n\n      const activeReference = new ActiveReference(this);\n\n      let disposed = false;\n      const dispose = () => {\n        if (disposed) {\n          throw new Error(\n            'Do not dispose an already-disposed ActiveReference.',\n          );\n        }\n        disposed = true;\n        if (activeReference.__original == null) {\n          throw new Error(\n            'Attempted to dispose an active reference, but it was already disposed. ' +\n              'This indicates a bug in reference-counted-pointer.',\n          );\n        }\n        activeReference.__original = null;\n        if (this.__state == null) {\n          throw new Error(\n            'Attempted to dispose, but the underlying reference counted pointer was disposed. ' +\n              'This indicates a bug in reference-counted-pointer.',\n          );\n        }\n        this.__state.activeReferenceCount--;\n        this.__maybeDispose();\n      };\n\n      return [activeReference, dispose];\n    } else {\n      return null;\n    }\n  }\n\n  private __maybeDispose() {\n    if (this.__state == null) {\n      throw new Error(\n        '__maybeDispose was called, but the reference counted pointer was disposed. ' +\n          'This indicates a bug in reference-counted-pointer.',\n      );\n    }\n    if (this.__state.activeReferenceCount === 0) {\n      this.__state.dispose();\n      this.__state = null;\n    }\n  }\n}\n\nclass ActiveReference<T> implements ReferenceCountedPointer<T> {\n  // Invariant: __original !== null => the original is not disposed.\n  __original: RefCounter<T> | null;\n\n  constructor(original: RefCounter<T>) {\n    this.__original = original;\n  }\n\n  isDisposed(): boolean {\n    return this.__original == null;\n  }\n\n  cloneIfNotDisposed(): ItemCleanupPair<ReferenceCountedPointer<T>> | null {\n    return this.__original?.retainIfNotDisposed() ?? null;\n  }\n\n  getItemIfNotDisposed(): T | null {\n    return this.__original?.getIfNotDisposed() ?? null;\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;AA0BA,SAAgB,8BACd,MAC6C;AAG7C,QAFwC,IAAI,WAAW,KAAK,CAErB,qBAAqB;;AA0B9D,IAAM,aAAN,MAAoB;;;;;CAOlB,YAAY,CAAC,MAAM,UAA8B;AAC/C,OAAK,UAAU;GACb;GACA;GACA,sBAAsB;GACvB;;CAGH,mBAA6B;AAC3B,SAAO,KAAK,WAAW,OAAO,OAAO,KAAK,QAAQ;;CAGpD,sBAA0E;AACxE,MAAI,KAAK,WAAW,MAAM;AACxB,QAAK,QAAQ;GAEb,MAAM,kBAAkB,IAAI,gBAAgB,KAAK;GAEjD,IAAI,WAAW;GACf,MAAM,gBAAgB;AACpB,QAAI,SACF,OAAM,IAAI,MACR,sDACD;AAEH,eAAW;AACX,QAAI,gBAAgB,cAAc,KAChC,OAAM,IAAI,MACR,4HAED;AAEH,oBAAgB,aAAa;AAC7B,QAAI,KAAK,WAAW,KAClB,OAAM,IAAI,MACR,sIAED;AAEH,SAAK,QAAQ;AACb,SAAK,gBAAgB;;AAGvB,UAAO,CAAC,iBAAiB,QAAQ;QAEjC,QAAO;;CAIX,AAAQ,iBAAiB;AACvB,MAAI,KAAK,WAAW,KAClB,OAAM,IAAI,MACR,gIAED;AAEH,MAAI,KAAK,QAAQ,yBAAyB,GAAG;AAC3C,QAAK,QAAQ,SAAS;AACtB,QAAK,UAAU;;;;AAKrB,IAAM,kBAAN,MAA+D;CAI7D,YAAY,UAAyB;AACnC,OAAK,aAAa;;CAGpB,aAAsB;AACpB,SAAO,KAAK,cAAc;;CAG5B,qBAAyE;AACvE,SAAO,KAAK,YAAY,qBAAqB,IAAI;;CAGnD,uBAAiC;AAC/B,SAAO,KAAK,YAAY,kBAAkB,IAAI"}

package/dist/index.d.mts

@@ -0,0 +1,2 @@
+import { ReferenceCountedPointer, createReferenceCountedPointer } from "./createReferenceCountedPointer.mjs";
+export { ReferenceCountedPointer, createReferenceCountedPointer };

package/dist/index.d.ts

@@ -1,2 +1,2 @@
-export * from './createReferenceCountedPointer';
-//# sourceMappingURL=index.d.ts.map
+import { ReferenceCountedPointer, createReferenceCountedPointer } from "./createReferenceCountedPointer.js";
+export { ReferenceCountedPointer, createReferenceCountedPointer };

package/dist/index.js

@@ -1,17 +1,3 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./createReferenceCountedPointer"), exports);
+const require_createReferenceCountedPointer = require('./createReferenceCountedPointer.js');
+
+exports.createReferenceCountedPointer = require_createReferenceCountedPointer.createReferenceCountedPointer;

package/dist/index.mjs

@@ -0,0 +1,3 @@
+import { createReferenceCountedPointer } from "./createReferenceCountedPointer.mjs";
+
+export { createReferenceCountedPointer };

package/package.json

@@ -1,14 +1,14 @@
 {
   "name": "@isograph/reference-counted-pointer",
-  "version": "0.5.0",
+  "version": "0.5.1",
   "description": "Reference counted pointers enable sharing of disposable items.",
   "homepage": "https://isograph.dev",
-  "main": "dist/index.js",
-  "types": "dist/index.d.ts",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
   "author": "Isograph Labs",
   "license": "MIT",
   "dependencies": {
-    "@isograph/disposable-types": "0.5.0"
+    "@isograph/disposable-types": "0.5.1"
   },
   "devDependencies": {
     "typescript": "5.6.3"
@@ -19,9 +19,17 @@
     "directory": "libs/isograph-reference-counted-pointer"
   },
   "sideEffects": false,
+  "module": "./dist/index.mjs",
+  "exports": {
+    ".": {
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.js"
+    },
+    "./package.json": "./package.json"
+  },
   "scripts": {
-    "compile-libs": "rimraf dist && tsc -p tsconfig.pkg.json",
-    "compile-watch": "tsc -p tsconfig.pkg.json --watch",
+    "compile-libs": "tsdown",
+    "watch-libs": "tsdown --watch",
     "test": "vitest run",
     "test-watch": "vitest watch",
     "coverage": "vitest run --coverage",

package/src/createReferenceCountedPointer.ts

@@ -71,11 +71,11 @@ class RefCounter<T> {
   }
 
   getIfNotDisposed(): T | null {
-    return this.__state === null ? null : this.__state.item;
+    return this.__state == null ? null : this.__state.item;
   }
 
   retainIfNotDisposed(): ItemCleanupPair<ReferenceCountedPointer<T>> | null {
-    if (this.__state !== null) {
+    if (this.__state != null) {
       this.__state.activeReferenceCount++;
 
       const activeReference = new ActiveReference(this);
@@ -88,14 +88,14 @@ class RefCounter<T> {
           );
         }
         disposed = true;
-        if (activeReference.__original === null) {
+        if (activeReference.__original == null) {
           throw new Error(
             'Attempted to dispose an active reference, but it was already disposed. ' +
               'This indicates a bug in reference-counted-pointer.',
           );
         }
         activeReference.__original = null;
-        if (this.__state === null) {
+        if (this.__state == null) {
           throw new Error(
             'Attempted to dispose, but the underlying reference counted pointer was disposed. ' +
               'This indicates a bug in reference-counted-pointer.',
@@ -112,7 +112,7 @@ class RefCounter<T> {
   }
 
   private __maybeDispose() {
-    if (this.__state === null) {
+    if (this.__state == null) {
       throw new Error(
         '__maybeDispose was called, but the reference counted pointer was disposed. ' +
           'This indicates a bug in reference-counted-pointer.',
@@ -134,7 +134,7 @@ class ActiveReference<T> implements ReferenceCountedPointer<T> {
   }
 
   isDisposed(): boolean {
-    return this.__original === null;
+    return this.__original == null;
   }
 
   cloneIfNotDisposed(): ItemCleanupPair<ReferenceCountedPointer<T>> | null {

package/dist/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,iCAAiC,CAAC"}