extract-base-iterator 2.5.0 → 2.6.0

package/dist/cjs/shared/Lock.d.cts

@@ -0,0 +1,52 @@
+/**
+ * Lock - Reference counting for iterator lifecycle
+ *
+ * Ensures the iterator doesn't complete until all entries have been processed.
+ * Uses cleanup registration pattern so each iterator can register its specific
+ * cleanup functions (e.g., close file descriptors, delete temp files, end parsers).
+ *
+ * Usage:
+ *   const lock = new Lock();
+ *   lock.onDestroy = (err) => BaseIterator.prototype.end.call(this, err);
+ *   lock.registerCleanup(() => { this.extract.end(); });
+ *   lock.registerCleanup(() => { fs.unlinkSync(this.tempPath); });
+ *
+ *   // For each entry:
+ *   lock.retain();
+ *   // ... when entry is consumed:
+ *   lock.release();
+ *
+ *   // When iteration complete:
+ *   lock.err = err; // optional error
+ *   lock.release(); // Initial count
+ */
+export type CleanupFn = () => void;
+export default class Lock {
+    private count;
+    private cleanupFns;
+    /** Error to pass to onDestroy callback */
+    err: Error | null;
+    /** Called after all cleanups when count reaches 0 */
+    onDestroy: ((err: Error | null) => void) | null;
+    /**
+     * Register a cleanup function to be called when the lock is destroyed.
+     * Cleanup functions are called in registration order, before onDestroy.
+     * @param fn Cleanup function (should not throw)
+     */
+    registerCleanup(fn: CleanupFn): void;
+    /**
+     * Increment reference count.
+     * Call when starting to process a new entry.
+     */
+    retain(): void;
+    /**
+     * Decrement reference count.
+     * Call when an entry has been fully consumed.
+     * When count reaches 0, cleanup is triggered.
+     */
+    release(): void;
+    /**
+     * Internal cleanup - called when reference count reaches 0
+     */
+    private _destroy;
+}

package/dist/cjs/shared/Lock.d.ts

@@ -0,0 +1,52 @@
+/**
+ * Lock - Reference counting for iterator lifecycle
+ *
+ * Ensures the iterator doesn't complete until all entries have been processed.
+ * Uses cleanup registration pattern so each iterator can register its specific
+ * cleanup functions (e.g., close file descriptors, delete temp files, end parsers).
+ *
+ * Usage:
+ *   const lock = new Lock();
+ *   lock.onDestroy = (err) => BaseIterator.prototype.end.call(this, err);
+ *   lock.registerCleanup(() => { this.extract.end(); });
+ *   lock.registerCleanup(() => { fs.unlinkSync(this.tempPath); });
+ *
+ *   // For each entry:
+ *   lock.retain();
+ *   // ... when entry is consumed:
+ *   lock.release();
+ *
+ *   // When iteration complete:
+ *   lock.err = err; // optional error
+ *   lock.release(); // Initial count
+ */
+export type CleanupFn = () => void;
+export default class Lock {
+    private count;
+    private cleanupFns;
+    /** Error to pass to onDestroy callback */
+    err: Error | null;
+    /** Called after all cleanups when count reaches 0 */
+    onDestroy: ((err: Error | null) => void) | null;
+    /**
+     * Register a cleanup function to be called when the lock is destroyed.
+     * Cleanup functions are called in registration order, before onDestroy.
+     * @param fn Cleanup function (should not throw)
+     */
+    registerCleanup(fn: CleanupFn): void;
+    /**
+     * Increment reference count.
+     * Call when starting to process a new entry.
+     */
+    retain(): void;
+    /**
+     * Decrement reference count.
+     * Call when an entry has been fully consumed.
+     * When count reaches 0, cleanup is triggered.
+     */
+    release(): void;
+    /**
+     * Internal cleanup - called when reference count reaches 0
+     */
+    private _destroy;
+}

package/dist/cjs/shared/Lock.js

@@ -0,0 +1,95 @@
+/**
+ * Lock - Reference counting for iterator lifecycle
+ *
+ * Ensures the iterator doesn't complete until all entries have been processed.
+ * Uses cleanup registration pattern so each iterator can register its specific
+ * cleanup functions (e.g., close file descriptors, delete temp files, end parsers).
+ *
+ * Usage:
+ *   const lock = new Lock();
+ *   lock.onDestroy = (err) => BaseIterator.prototype.end.call(this, err);
+ *   lock.registerCleanup(() => { this.extract.end(); });
+ *   lock.registerCleanup(() => { fs.unlinkSync(this.tempPath); });
+ *
+ *   // For each entry:
+ *   lock.retain();
+ *   // ... when entry is consumed:
+ *   lock.release();
+ *
+ *   // When iteration complete:
+ *   lock.err = err; // optional error
+ *   lock.release(); // Initial count
+ */ "use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "default", {
+    enumerable: true,
+    get: function() {
+        return Lock;
+    }
+});
+function _class_call_check(instance, Constructor) {
+    if (!(instance instanceof Constructor)) {
+        throw new TypeError("Cannot call a class as a function");
+    }
+}
+var Lock = /*#__PURE__*/ function() {
+    "use strict";
+    function Lock() {
+        _class_call_check(this, Lock);
+        this.count = 1;
+        this.cleanupFns = [];
+        /** Error to pass to onDestroy callback */ this.err = null;
+        /** Called after all cleanups when count reaches 0 */ this.onDestroy = null;
+    }
+    var _proto = Lock.prototype;
+    /**
+   * Register a cleanup function to be called when the lock is destroyed.
+   * Cleanup functions are called in registration order, before onDestroy.
+   * @param fn Cleanup function (should not throw)
+   */ _proto.registerCleanup = function registerCleanup(fn) {
+        this.cleanupFns.push(fn);
+    };
+    /**
+   * Increment reference count.
+   * Call when starting to process a new entry.
+   */ _proto.retain = function retain() {
+        this.count++;
+    };
+    /**
+   * Decrement reference count.
+   * Call when an entry has been fully consumed.
+   * When count reaches 0, cleanup is triggered.
+   */ _proto.release = function release() {
+        if (this.count <= 0) {
+            throw new Error('Lock count is corrupted');
+        }
+        this.count--;
+        if (this.count === 0) {
+            this._destroy();
+        }
+    };
+    /**
+   * Internal cleanup - called when reference count reaches 0
+   */ _proto._destroy = function _destroy() {
+        // Run all registered cleanup functions in order
+        // Note: Use traditional for loop for Node 0.8 compatibility (no Symbol.iterator)
+        var fns = this.cleanupFns;
+        for(var i = 0; i < fns.length; i++){
+            try {
+                fns[i]();
+            } catch (_e) {
+            // Ignore cleanup errors to ensure all cleanup runs
+            }
+        }
+        this.cleanupFns = [];
+        // Call onDestroy callback LAST (typically calls iterator.end())
+        if (this.onDestroy) {
+            this.onDestroy(this.err);
+            this.onDestroy = null;
+        }
+    };
+    return Lock;
+}();
+/* CJS INTEROP */ if (exports.__esModule && exports.default) { try { Object.defineProperty(exports.default, '__esModule', { value: true }); for (var key in exports) { exports.default[key] = exports[key]; } } catch (_) {}; module.exports = exports.default; }

package/dist/cjs/shared/Lock.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/iterators/extract-base-iterator/src/shared/Lock.ts"],"sourcesContent":["/**\n * Lock - Reference counting for iterator lifecycle\n *\n * Ensures the iterator doesn't complete until all entries have been processed.\n * Uses cleanup registration pattern so each iterator can register its specific\n * cleanup functions (e.g., close file descriptors, delete temp files, end parsers).\n *\n * Usage:\n *   const lock = new Lock();\n *   lock.onDestroy = (err) => BaseIterator.prototype.end.call(this, err);\n *   lock.registerCleanup(() => { this.extract.end(); });\n *   lock.registerCleanup(() => { fs.unlinkSync(this.tempPath); });\n *\n *   // For each entry:\n *   lock.retain();\n *   // ... when entry is consumed:\n *   lock.release();\n *\n *   // When iteration complete:\n *   lock.err = err; // optional error\n *   lock.release(); // Initial count\n */\n\nexport type CleanupFn = () => void;\n\nexport default class Lock {\n  private count = 1;\n  private cleanupFns: CleanupFn[] = [];\n\n  /** Error to pass to onDestroy callback */\n  err: Error | null = null;\n\n  /** Called after all cleanups when count reaches 0 */\n  onDestroy: ((err: Error | null) => void) | null = null;\n\n  /**\n   * Register a cleanup function to be called when the lock is destroyed.\n   * Cleanup functions are called in registration order, before onDestroy.\n   * @param fn Cleanup function (should not throw)\n   */\n  registerCleanup(fn: CleanupFn): void {\n    this.cleanupFns.push(fn);\n  }\n\n  /**\n   * Increment reference count.\n   * Call when starting to process a new entry.\n   */\n  retain(): void {\n    this.count++;\n  }\n\n  /**\n   * Decrement reference count.\n   * Call when an entry has been fully consumed.\n   * When count reaches 0, cleanup is triggered.\n   */\n  release(): void {\n    if (this.count <= 0) {\n      throw new Error('Lock count is corrupted');\n    }\n    this.count--;\n    if (this.count === 0) {\n      this._destroy();\n    }\n  }\n\n  /**\n   * Internal cleanup - called when reference count reaches 0\n   */\n  private _destroy(): void {\n    // Run all registered cleanup functions in order\n    // Note: Use traditional for loop for Node 0.8 compatibility (no Symbol.iterator)\n    const fns = this.cleanupFns;\n    for (let i = 0; i < fns.length; i++) {\n      try {\n        fns[i]();\n      } catch (_e) {\n        // Ignore cleanup errors to ensure all cleanup runs\n      }\n    }\n    this.cleanupFns = [];\n\n    // Call onDestroy callback LAST (typically calls iterator.end())\n    if (this.onDestroy) {\n      this.onDestroy(this.err);\n      this.onDestroy = null;\n    }\n  }\n}\n"],"names":["Lock","count","cleanupFns","err","onDestroy","registerCleanup","fn","push","retain","release","Error","_destroy","fns","i","length","_e"],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;CAqBC;;;;;;;eAIoBA;;;;;;;;AAAN,IAAA,AAAMA,qBAAN;;aAAMA;gCAAAA;aACXC,QAAQ;aACRC,aAA0B,EAAE;QAEpC,wCAAwC,QACxCC,MAAoB;QAEpB,mDAAmD,QACnDC,YAAkD;;iBAR/BJ;IAUnB;;;;GAIC,GACDK,OAAAA,eAEC,GAFDA,SAAAA,gBAAgBC,EAAa;QAC3B,IAAI,CAACJ,UAAU,CAACK,IAAI,CAACD;IACvB;IAEA;;;GAGC,GACDE,OAAAA,MAEC,GAFDA,SAAAA;QACE,IAAI,CAACP,KAAK;IACZ;IAEA;;;;GAIC,GACDQ,OAAAA,OAQC,GARDA,SAAAA;QACE,IAAI,IAAI,CAACR,KAAK,IAAI,GAAG;YACnB,MAAM,IAAIS,MAAM;QAClB;QACA,IAAI,CAACT,KAAK;QACV,IAAI,IAAI,CAACA,KAAK,KAAK,GAAG;YACpB,IAAI,CAACU,QAAQ;QACf;IACF;IAEA;;GAEC,GACD,OAAQA,QAkBP,GAlBD,SAAQA;QACN,gDAAgD;QAChD,iFAAiF;QACjF,IAAMC,MAAM,IAAI,CAACV,UAAU;QAC3B,IAAK,IAAIW,IAAI,GAAGA,IAAID,IAAIE,MAAM,EAAED,IAAK;YACnC,IAAI;gBACFD,GAAG,CAACC,EAAE;YACR,EAAE,OAAOE,IAAI;YACX,mDAAmD;YACrD;QACF;QACA,IAAI,CAACb,UAAU,GAAG,EAAE;QAEpB,gEAAgE;QAChE,IAAI,IAAI,CAACE,SAAS,EAAE;YAClB,IAAI,CAACA,SAAS,CAAC,IAAI,CAACD,GAAG;YACvB,IAAI,CAACC,SAAS,GAAG;QACnB;IACF;WA/DmBJ"}

package/dist/cjs/shared/index.d.cts

@@ -13,3 +13,4 @@ export { default as BufferList } from './BufferList.js';
 export { allocBuffer, allocBufferUnsafe, bufferCompare, bufferConcat, bufferEquals, bufferFrom, bufferSliceCopy, createInflateRawStream, inflateRaw, isNaN, objectAssign, readUInt64LE, setImmediateFn, writeUInt64LE, } from './compat.js';
 export { crc32, crc32Region, verifyCrc32, verifyCrc32Region } from './crc32.js';
 export { default as EntryStream } from './EntryStream.js';
+export { type CleanupFn, default as Lock } from './Lock.js';

package/dist/cjs/shared/index.d.ts

@@ -13,3 +13,4 @@ export { default as BufferList } from './BufferList.js';
 export { allocBuffer, allocBufferUnsafe, bufferCompare, bufferConcat, bufferEquals, bufferFrom, bufferSliceCopy, createInflateRawStream, inflateRaw, isNaN, objectAssign, readUInt64LE, setImmediateFn, writeUInt64LE, } from './compat.js';
 export { crc32, crc32Region, verifyCrc32, verifyCrc32Region } from './crc32.js';
 export { default as EntryStream } from './EntryStream.js';
+export { type CleanupFn, default as Lock } from './Lock.js';

package/dist/cjs/shared/index.js

@@ -25,6 +25,9 @@ _export(exports, {
     get EntryStream () {
         return _EntryStreamts.default;
     },
+    get Lock () {
+        return _Lockts.default;
+    },
     get allocBuffer () {
         return _compatts.allocBuffer;
     },
@@ -84,6 +87,7 @@ var _BufferListts = /*#__PURE__*/ _interop_require_default(require("./BufferList
 var _compatts = require("./compat.js");
 var _crc32ts = require("./crc32.js");
 var _EntryStreamts = /*#__PURE__*/ _interop_require_default(require("./EntryStream.js"));
+var _Lockts = /*#__PURE__*/ _interop_require_default(require("./Lock.js"));
 function _interop_require_default(obj) {
     return obj && obj.__esModule ? obj : {
         default: obj

package/dist/cjs/shared/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":["/Users/kevin/Dev/OpenSource/iterators/extract-base-iterator/src/shared/index.ts"],"sourcesContent":["/**\n * Shared utilities for iterator libraries\n *\n * These utilities are designed to be used by:\n * - zip-iterator\n * - 7z-iterator\n * - tar-iterator\n * - Any other archive iterator library\n *\n * All utilities support Node.js 0.8+\n */\n\nexport { default as BufferList } from './BufferList.ts';\nexport {\n  allocBuffer,\n  allocBufferUnsafe,\n  bufferCompare,\n  bufferConcat,\n  bufferEquals,\n  bufferFrom,\n  bufferSliceCopy,\n  createInflateRawStream,\n  inflateRaw,\n  isNaN,\n  objectAssign,\n  readUInt64LE,\n  setImmediateFn,\n  writeUInt64LE,\n} from './compat.ts';\nexport { crc32, crc32Region, verifyCrc32, verifyCrc32Region } from './crc32.ts';\nexport { default as EntryStream } from './EntryStream.ts';\n"],"names":["BufferList","EntryStream","allocBuffer","allocBufferUnsafe","bufferCompare","bufferConcat","bufferEquals","bufferFrom","bufferSliceCopy","crc32","crc32Region","createInflateRawStream","inflateRaw","isNaN","objectAssign","readUInt64LE","setImmediateFn","verifyCrc32","verifyCrc32Region","writeUInt64LE"],"mappings":"AAAA;;;;;;;;;;CAUC;;;;;;;;;;;QAEmBA;eAAAA,qBAAU;;QAkBVC;eAAAA,sBAAW;;QAhB7BC;eAAAA,qBAAW;;QACXC;eAAAA,2BAAiB;;QACjBC;eAAAA,uBAAa;;QACbC;eAAAA,sBAAY;;QACZC;eAAAA,sBAAY;;QACZC;eAAAA,oBAAU;;QACVC;eAAAA,yBAAe;;QASRC;eAAAA,cAAK;;QAAEC;eAAAA,oBAAW;;QARzBC;eAAAA,gCAAsB;;QACtBC;eAAAA,oBAAU;;QACVC;eAAAA,eAAK;;QACLC;eAAAA,sBAAY;;QACZC;eAAAA,sBAAY;;QACZC;eAAAA,wBAAc;;QAGaC;eAAAA,oBAAW;;QAAEC;eAAAA,0BAAiB;;QAFzDC;eAAAA,uBAAa;;;mEAfuB;wBAgB/B;uBAC4D;oEAC5B"}
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/iterators/extract-base-iterator/src/shared/index.ts"],"sourcesContent":["/**\n * Shared utilities for iterator libraries\n *\n * These utilities are designed to be used by:\n * - zip-iterator\n * - 7z-iterator\n * - tar-iterator\n * - Any other archive iterator library\n *\n * All utilities support Node.js 0.8+\n */\n\nexport { default as BufferList } from './BufferList.ts';\nexport {\n  allocBuffer,\n  allocBufferUnsafe,\n  bufferCompare,\n  bufferConcat,\n  bufferEquals,\n  bufferFrom,\n  bufferSliceCopy,\n  createInflateRawStream,\n  inflateRaw,\n  isNaN,\n  objectAssign,\n  readUInt64LE,\n  setImmediateFn,\n  writeUInt64LE,\n} from './compat.ts';\nexport { crc32, crc32Region, verifyCrc32, verifyCrc32Region } from './crc32.ts';\nexport { default as EntryStream } from './EntryStream.ts';\nexport { type CleanupFn, default as Lock } from './Lock.ts';\n"],"names":["BufferList","EntryStream","Lock","allocBuffer","allocBufferUnsafe","bufferCompare","bufferConcat","bufferEquals","bufferFrom","bufferSliceCopy","crc32","crc32Region","createInflateRawStream","inflateRaw","isNaN","objectAssign","readUInt64LE","setImmediateFn","verifyCrc32","verifyCrc32Region","writeUInt64LE"],"mappings":"AAAA;;;;;;;;;;CAUC;;;;;;;;;;;QAEmBA;eAAAA,qBAAU;;QAkBVC;eAAAA,sBAAW;;QACKC;eAAAA,eAAI;;QAjBtCC;eAAAA,qBAAW;;QACXC;eAAAA,2BAAiB;;QACjBC;eAAAA,uBAAa;;QACbC;eAAAA,sBAAY;;QACZC;eAAAA,sBAAY;;QACZC;eAAAA,oBAAU;;QACVC;eAAAA,yBAAe;;QASRC;eAAAA,cAAK;;QAAEC;eAAAA,oBAAW;;QARzBC;eAAAA,gCAAsB;;QACtBC;eAAAA,oBAAU;;QACVC;eAAAA,eAAK;;QACLC;eAAAA,sBAAY;;QACZC;eAAAA,sBAAY;;QACZC;eAAAA,wBAAc;;QAGaC;eAAAA,oBAAW;;QAAEC;eAAAA,0BAAiB;;QAFzDC;eAAAA,uBAAa;;;mEAfuB;wBAgB/B;uBAC4D;oEAC5B;6DACS"}

package/dist/esm/shared/Lock.d.ts

@@ -0,0 +1,52 @@
+/**
+ * Lock - Reference counting for iterator lifecycle
+ *
+ * Ensures the iterator doesn't complete until all entries have been processed.
+ * Uses cleanup registration pattern so each iterator can register its specific
+ * cleanup functions (e.g., close file descriptors, delete temp files, end parsers).
+ *
+ * Usage:
+ *   const lock = new Lock();
+ *   lock.onDestroy = (err) => BaseIterator.prototype.end.call(this, err);
+ *   lock.registerCleanup(() => { this.extract.end(); });
+ *   lock.registerCleanup(() => { fs.unlinkSync(this.tempPath); });
+ *
+ *   // For each entry:
+ *   lock.retain();
+ *   // ... when entry is consumed:
+ *   lock.release();
+ *
+ *   // When iteration complete:
+ *   lock.err = err; // optional error
+ *   lock.release(); // Initial count
+ */
+export type CleanupFn = () => void;
+export default class Lock {
+    private count;
+    private cleanupFns;
+    /** Error to pass to onDestroy callback */
+    err: Error | null;
+    /** Called after all cleanups when count reaches 0 */
+    onDestroy: ((err: Error | null) => void) | null;
+    /**
+     * Register a cleanup function to be called when the lock is destroyed.
+     * Cleanup functions are called in registration order, before onDestroy.
+     * @param fn Cleanup function (should not throw)
+     */
+    registerCleanup(fn: CleanupFn): void;
+    /**
+     * Increment reference count.
+     * Call when starting to process a new entry.
+     */
+    retain(): void;
+    /**
+     * Decrement reference count.
+     * Call when an entry has been fully consumed.
+     * When count reaches 0, cleanup is triggered.
+     */
+    release(): void;
+    /**
+     * Internal cleanup - called when reference count reaches 0
+     */
+    private _destroy;
+}

package/dist/esm/shared/Lock.js

@@ -0,0 +1,76 @@
+/**
+ * Lock - Reference counting for iterator lifecycle
+ *
+ * Ensures the iterator doesn't complete until all entries have been processed.
+ * Uses cleanup registration pattern so each iterator can register its specific
+ * cleanup functions (e.g., close file descriptors, delete temp files, end parsers).
+ *
+ * Usage:
+ *   const lock = new Lock();
+ *   lock.onDestroy = (err) => BaseIterator.prototype.end.call(this, err);
+ *   lock.registerCleanup(() => { this.extract.end(); });
+ *   lock.registerCleanup(() => { fs.unlinkSync(this.tempPath); });
+ *
+ *   // For each entry:
+ *   lock.retain();
+ *   // ... when entry is consumed:
+ *   lock.release();
+ *
+ *   // When iteration complete:
+ *   lock.err = err; // optional error
+ *   lock.release(); // Initial count
+ */ let Lock = class Lock {
+    /**
+   * Register a cleanup function to be called when the lock is destroyed.
+   * Cleanup functions are called in registration order, before onDestroy.
+   * @param fn Cleanup function (should not throw)
+   */ registerCleanup(fn) {
+        this.cleanupFns.push(fn);
+    }
+    /**
+   * Increment reference count.
+   * Call when starting to process a new entry.
+   */ retain() {
+        this.count++;
+    }
+    /**
+   * Decrement reference count.
+   * Call when an entry has been fully consumed.
+   * When count reaches 0, cleanup is triggered.
+   */ release() {
+        if (this.count <= 0) {
+            throw new Error('Lock count is corrupted');
+        }
+        this.count--;
+        if (this.count === 0) {
+            this._destroy();
+        }
+    }
+    /**
+   * Internal cleanup - called when reference count reaches 0
+   */ _destroy() {
+        // Run all registered cleanup functions in order
+        // Note: Use traditional for loop for Node 0.8 compatibility (no Symbol.iterator)
+        const fns = this.cleanupFns;
+        for(let i = 0; i < fns.length; i++){
+            try {
+                fns[i]();
+            } catch (_e) {
+            // Ignore cleanup errors to ensure all cleanup runs
+            }
+        }
+        this.cleanupFns = [];
+        // Call onDestroy callback LAST (typically calls iterator.end())
+        if (this.onDestroy) {
+            this.onDestroy(this.err);
+            this.onDestroy = null;
+        }
+    }
+    constructor(){
+        this.count = 1;
+        this.cleanupFns = [];
+        /** Error to pass to onDestroy callback */ this.err = null;
+        /** Called after all cleanups when count reaches 0 */ this.onDestroy = null;
+    }
+};
+export { Lock as default };

package/dist/esm/shared/Lock.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/iterators/extract-base-iterator/src/shared/Lock.ts"],"sourcesContent":["/**\n * Lock - Reference counting for iterator lifecycle\n *\n * Ensures the iterator doesn't complete until all entries have been processed.\n * Uses cleanup registration pattern so each iterator can register its specific\n * cleanup functions (e.g., close file descriptors, delete temp files, end parsers).\n *\n * Usage:\n *   const lock = new Lock();\n *   lock.onDestroy = (err) => BaseIterator.prototype.end.call(this, err);\n *   lock.registerCleanup(() => { this.extract.end(); });\n *   lock.registerCleanup(() => { fs.unlinkSync(this.tempPath); });\n *\n *   // For each entry:\n *   lock.retain();\n *   // ... when entry is consumed:\n *   lock.release();\n *\n *   // When iteration complete:\n *   lock.err = err; // optional error\n *   lock.release(); // Initial count\n */\n\nexport type CleanupFn = () => void;\n\nexport default class Lock {\n  private count = 1;\n  private cleanupFns: CleanupFn[] = [];\n\n  /** Error to pass to onDestroy callback */\n  err: Error | null = null;\n\n  /** Called after all cleanups when count reaches 0 */\n  onDestroy: ((err: Error | null) => void) | null = null;\n\n  /**\n   * Register a cleanup function to be called when the lock is destroyed.\n   * Cleanup functions are called in registration order, before onDestroy.\n   * @param fn Cleanup function (should not throw)\n   */\n  registerCleanup(fn: CleanupFn): void {\n    this.cleanupFns.push(fn);\n  }\n\n  /**\n   * Increment reference count.\n   * Call when starting to process a new entry.\n   */\n  retain(): void {\n    this.count++;\n  }\n\n  /**\n   * Decrement reference count.\n   * Call when an entry has been fully consumed.\n   * When count reaches 0, cleanup is triggered.\n   */\n  release(): void {\n    if (this.count <= 0) {\n      throw new Error('Lock count is corrupted');\n    }\n    this.count--;\n    if (this.count === 0) {\n      this._destroy();\n    }\n  }\n\n  /**\n   * Internal cleanup - called when reference count reaches 0\n   */\n  private _destroy(): void {\n    // Run all registered cleanup functions in order\n    // Note: Use traditional for loop for Node 0.8 compatibility (no Symbol.iterator)\n    const fns = this.cleanupFns;\n    for (let i = 0; i < fns.length; i++) {\n      try {\n        fns[i]();\n      } catch (_e) {\n        // Ignore cleanup errors to ensure all cleanup runs\n      }\n    }\n    this.cleanupFns = [];\n\n    // Call onDestroy callback LAST (typically calls iterator.end())\n    if (this.onDestroy) {\n      this.onDestroy(this.err);\n      this.onDestroy = null;\n    }\n  }\n}\n"],"names":["Lock","registerCleanup","fn","cleanupFns","push","retain","count","release","Error","_destroy","fns","i","length","_e","onDestroy","err"],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;CAqBC,GAIc,IAAA,AAAMA,OAAN,MAAMA;IAUnB;;;;GAIC,GACDC,gBAAgBC,EAAa,EAAQ;QACnC,IAAI,CAACC,UAAU,CAACC,IAAI,CAACF;IACvB;IAEA;;;GAGC,GACDG,SAAe;QACb,IAAI,CAACC,KAAK;IACZ;IAEA;;;;GAIC,GACDC,UAAgB;QACd,IAAI,IAAI,CAACD,KAAK,IAAI,GAAG;YACnB,MAAM,IAAIE,MAAM;QAClB;QACA,IAAI,CAACF,KAAK;QACV,IAAI,IAAI,CAACA,KAAK,KAAK,GAAG;YACpB,IAAI,CAACG,QAAQ;QACf;IACF;IAEA;;GAEC,GACD,AAAQA,WAAiB;QACvB,gDAAgD;QAChD,iFAAiF;QACjF,MAAMC,MAAM,IAAI,CAACP,UAAU;QAC3B,IAAK,IAAIQ,IAAI,GAAGA,IAAID,IAAIE,MAAM,EAAED,IAAK;YACnC,IAAI;gBACFD,GAAG,CAACC,EAAE;YACR,EAAE,OAAOE,IAAI;YACX,mDAAmD;YACrD;QACF;QACA,IAAI,CAACV,UAAU,GAAG,EAAE;QAEpB,gEAAgE;QAChE,IAAI,IAAI,CAACW,SAAS,EAAE;YAClB,IAAI,CAACA,SAAS,CAAC,IAAI,CAACC,GAAG;YACvB,IAAI,CAACD,SAAS,GAAG;QACnB;IACF;;aA9DQR,QAAQ;aACRH,aAA0B,EAAE;QAEpC,wCAAwC,QACxCY,MAAoB;QAEpB,mDAAmD,QACnDD,YAAkD;;AAwDpD;AAhEA,SAAqBd,kBAgEpB"}

package/dist/esm/shared/index.d.ts

@@ -13,3 +13,4 @@ export { default as BufferList } from './BufferList.js';
 export { allocBuffer, allocBufferUnsafe, bufferCompare, bufferConcat, bufferEquals, bufferFrom, bufferSliceCopy, createInflateRawStream, inflateRaw, isNaN, objectAssign, readUInt64LE, setImmediateFn, writeUInt64LE, } from './compat.js';
 export { crc32, crc32Region, verifyCrc32, verifyCrc32Region } from './crc32.js';
 export { default as EntryStream } from './EntryStream.js';
+export { type CleanupFn, default as Lock } from './Lock.js';

package/dist/esm/shared/index.js

@@ -12,3 +12,4 @@
 export { allocBuffer, allocBufferUnsafe, bufferCompare, bufferConcat, bufferEquals, bufferFrom, bufferSliceCopy, createInflateRawStream, inflateRaw, isNaN, objectAssign, readUInt64LE, setImmediateFn, writeUInt64LE } from './compat.js';
 export { crc32, crc32Region, verifyCrc32, verifyCrc32Region } from './crc32.js';
 export { default as EntryStream } from './EntryStream.js';
+export { default as Lock } from './Lock.js';

package/dist/esm/shared/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":["/Users/kevin/Dev/OpenSource/iterators/extract-base-iterator/src/shared/index.ts"],"sourcesContent":["/**\n * Shared utilities for iterator libraries\n *\n * These utilities are designed to be used by:\n * - zip-iterator\n * - 7z-iterator\n * - tar-iterator\n * - Any other archive iterator library\n *\n * All utilities support Node.js 0.8+\n */\n\nexport { default as BufferList } from './BufferList.ts';\nexport {\n  allocBuffer,\n  allocBufferUnsafe,\n  bufferCompare,\n  bufferConcat,\n  bufferEquals,\n  bufferFrom,\n  bufferSliceCopy,\n  createInflateRawStream,\n  inflateRaw,\n  isNaN,\n  objectAssign,\n  readUInt64LE,\n  setImmediateFn,\n  writeUInt64LE,\n} from './compat.ts';\nexport { crc32, crc32Region, verifyCrc32, verifyCrc32Region } from './crc32.ts';\nexport { default as EntryStream } from './EntryStream.ts';\n"],"names":["default","BufferList","allocBuffer","allocBufferUnsafe","bufferCompare","bufferConcat","bufferEquals","bufferFrom","bufferSliceCopy","createInflateRawStream","inflateRaw","isNaN","objectAssign","readUInt64LE","setImmediateFn","writeUInt64LE","crc32","crc32Region","verifyCrc32","verifyCrc32Region","EntryStream"],"mappings":"AAAA;;;;;;;;;;CAUC,GAED,SAASA,WAAWC,UAAU,QAAQ,kBAAkB;AACxD,SACEC,WAAW,EACXC,iBAAiB,EACjBC,aAAa,EACbC,YAAY,EACZC,YAAY,EACZC,UAAU,EACVC,eAAe,EACfC,sBAAsB,EACtBC,UAAU,EACVC,KAAK,EACLC,YAAY,EACZC,YAAY,EACZC,cAAc,EACdC,aAAa,QACR,cAAc;AACrB,SAASC,KAAK,EAAEC,WAAW,EAAEC,WAAW,EAAEC,iBAAiB,QAAQ,aAAa;AAChF,SAASnB,WAAWoB,WAAW,QAAQ,mBAAmB"}
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/iterators/extract-base-iterator/src/shared/index.ts"],"sourcesContent":["/**\n * Shared utilities for iterator libraries\n *\n * These utilities are designed to be used by:\n * - zip-iterator\n * - 7z-iterator\n * - tar-iterator\n * - Any other archive iterator library\n *\n * All utilities support Node.js 0.8+\n */\n\nexport { default as BufferList } from './BufferList.ts';\nexport {\n  allocBuffer,\n  allocBufferUnsafe,\n  bufferCompare,\n  bufferConcat,\n  bufferEquals,\n  bufferFrom,\n  bufferSliceCopy,\n  createInflateRawStream,\n  inflateRaw,\n  isNaN,\n  objectAssign,\n  readUInt64LE,\n  setImmediateFn,\n  writeUInt64LE,\n} from './compat.ts';\nexport { crc32, crc32Region, verifyCrc32, verifyCrc32Region } from './crc32.ts';\nexport { default as EntryStream } from './EntryStream.ts';\nexport { type CleanupFn, default as Lock } from './Lock.ts';\n"],"names":["default","BufferList","allocBuffer","allocBufferUnsafe","bufferCompare","bufferConcat","bufferEquals","bufferFrom","bufferSliceCopy","createInflateRawStream","inflateRaw","isNaN","objectAssign","readUInt64LE","setImmediateFn","writeUInt64LE","crc32","crc32Region","verifyCrc32","verifyCrc32Region","EntryStream","Lock"],"mappings":"AAAA;;;;;;;;;;CAUC,GAED,SAASA,WAAWC,UAAU,QAAQ,kBAAkB;AACxD,SACEC,WAAW,EACXC,iBAAiB,EACjBC,aAAa,EACbC,YAAY,EACZC,YAAY,EACZC,UAAU,EACVC,eAAe,EACfC,sBAAsB,EACtBC,UAAU,EACVC,KAAK,EACLC,YAAY,EACZC,YAAY,EACZC,cAAc,EACdC,aAAa,QACR,cAAc;AACrB,SAASC,KAAK,EAAEC,WAAW,EAAEC,WAAW,EAAEC,iBAAiB,QAAQ,aAAa;AAChF,SAASnB,WAAWoB,WAAW,QAAQ,mBAAmB;AAC1D,SAAyBpB,WAAWqB,IAAI,QAAQ,YAAY"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "extract-base-iterator",
-  "version": "2.5.0",
+  "version": "2.6.0",
   "description": "Base iterator for extract iterators like tar-iterator and zip-iterator",
   "keywords": [
     "extract",
@@ -43,7 +43,7 @@
     "version": "tsds version"
   },
   "dependencies": {
-    "fs-remove-compat": "^0.2.5",
+    "fs-remove-compat": "^1.0.0",
     "graceful-fs": "^4.2.11",
     "is-absolute": "^1.0.0",
     "lodash.compact": "^3.0.1",
@@ -60,7 +60,6 @@
     "cr": "^0.1.0",
     "fs-iterator": "^6.1.12",
     "fs-stats-spys": "^1.2.9",
-    "lodash.find": "^4.6.0",
     "node-version-use": "*",
     "pinkie-promise": "*",
     "ts-dev-stack": "*",