stack-base-iterator - npm Package Compare versions

Comparing version 1.2.20 to 1.2.21

dist/cjs/createProcessor.d.cts

@@ -1,2 +0,2 @@
-import type { Next, ProcessCallback, Processor, ProcessorOptions } from './types.js';
-export default function createProcessor<T>(next: Next, options: ProcessorOptions<T>, callback: ProcessCallback): Processor;
+import type { EachDoneCallback, Next, Processor, ProcessorOptions } from './types.js';
+export default function createProcessor<T>(next: Next<T>, options: ProcessorOptions<T>, callback: EachDoneCallback): Processor;

dist/cjs/createProcessor.d.ts

@@ -1,2 +0,2 @@
-import type { Next, ProcessCallback, Processor, ProcessorOptions } from './types.js';
-export default function createProcessor<T>(next: Next, options: ProcessorOptions<T>, callback: ProcessCallback): Processor;
+import type { EachDoneCallback, Next, Processor, ProcessorOptions } from './types.js';
+export default function createProcessor<T>(next: Next<T>, options: ProcessorOptions<T>, callback: EachDoneCallback): Processor;

dist/cjs/createProcessor.js

@@ -51,3 +51,6 @@ "use strict";
             if (options.done || options.stop(counter++)) break;
-            if (options.total >= options.limit) return processDone(null, options, callback);
+            if (options.total >= options.limit) {
+                processDone(null, options, callback);
+                return;
+            }
             options.total++;
@@ -54,0 +57,0 @@ options.counter++;

dist/cjs/createProcessor.js.map

@@ -1,1 +0,1 @@
-{"version":3,"sources":["/Users/kevin/Dev/OpenSource/iterators/stack-base-iterator/src/createProcessor.ts"],"sourcesContent":["import compat from 'async-compat';\n\nimport type { Next, ProcessCallback, Processor, ProcessorOptions } from './types.js';\n\nconst isError = (err?: Error): boolean => err && err.stack !== undefined && err.message !== undefined;\n\nfunction processDone<T>(err: Error, options: ProcessorOptions<T>, callback: ProcessCallback) {\n  // mark this iteration done\n  options.err = options.err || err;\n  options.done = true;\n\n  // process done\n  if (!options.done || options.counter > 0) return false;\n  callback(options.err, options.done);\n  return true;\n}\n\nfunction processResult(err, keep, options, callback) {\n  options.counter--;\n\n  // mark this iteration done\n  if ((err && compat.defaultValue(options.error(err), false)) || (!err && !compat.defaultValue(keep, true))) {\n    options.err = options.err || err;\n    options.done = true;\n  }\n\n  // process done\n  if (!options.done || options.counter > 0) return false;\n  callback(options.err, options.done);\n  return true;\n}\n\nexport default function createProcessor<T>(next: Next, options: ProcessorOptions<T>, callback: ProcessCallback): Processor {\n  let isProcessing = false;\n  return function processor(doneOrError?: Error | boolean) {\n    const error = doneOrError as Error;\n    if (doneOrError && processDone(isError(error) ? error : null, options, callback)) return;\n    if (isProcessing) return;\n    isProcessing = true;\n\n    let counter = 0;\n    while (options.counter < options.concurrency) {\n      if (options.done || options.stop(counter++)) break;\n      if (options.total >= options.limit) return processDone(null, options, callback);\n      options.total++;\n      options.counter++;\n\n      next((err, value) => {\n        if (err || value === null) {\n          return !processResult(err, false, options, callback) && !isProcessing ? processor() : undefined;\n        }\n        compat.asyncFunction(options.each, options.callbacks, value, (err, keep) => (!processResult(err, keep, options, callback) && !isProcessing ? processor() : undefined));\n      });\n    }\n\n    isProcessing = false;\n  };\n}\n"],"names":["createProcessor","isError","err","stack","undefined","message","processDone","options","callback","done","counter","processResult","keep","compat","defaultValue","error","next","isProcessing","processor","doneOrError","concurrency","stop","total","limit","value","asyncFunction","each","callbacks"],"mappings":";;;;+BAgCA;;;eAAwBA;;;kEAhCL;;;;;;AAInB,IAAMC,UAAU,SAACC;WAAyBA,OAAOA,IAAIC,KAAK,KAAKC,aAAaF,IAAIG,OAAO,KAAKD;;AAE5F,SAASE,YAAeJ,GAAU,EAAEK,OAA4B,EAAEC,QAAyB;IACzF,2BAA2B;IAC3BD,QAAQL,GAAG,GAAGK,QAAQL,GAAG,IAAIA;IAC7BK,QAAQE,IAAI,GAAG;IAEf,eAAe;IACf,IAAI,CAACF,QAAQE,IAAI,IAAIF,QAAQG,OAAO,GAAG,GAAG,OAAO;IACjDF,SAASD,QAAQL,GAAG,EAAEK,QAAQE,IAAI;IAClC,OAAO;AACT;AAEA,SAASE,cAAcT,GAAG,EAAEU,IAAI,EAAEL,OAAO,EAAEC,QAAQ;IACjDD,QAAQG,OAAO;IAEf,2BAA2B;IAC3B,IAAI,AAACR,OAAOW,oBAAM,CAACC,YAAY,CAACP,QAAQQ,KAAK,CAACb,MAAM,UAAY,CAACA,OAAO,CAACW,oBAAM,CAACC,YAAY,CAACF,MAAM,OAAQ;QACzGL,QAAQL,GAAG,GAAGK,QAAQL,GAAG,IAAIA;QAC7BK,QAAQE,IAAI,GAAG;IACjB;IAEA,eAAe;IACf,IAAI,CAACF,QAAQE,IAAI,IAAIF,QAAQG,OAAO,GAAG,GAAG,OAAO;IACjDF,SAASD,QAAQL,GAAG,EAAEK,QAAQE,IAAI;IAClC,OAAO;AACT;AAEe,SAAST,gBAAmBgB,IAAU,EAAET,OAA4B,EAAEC,QAAyB;IAC5G,IAAIS,eAAe;IACnB,OAAO,SAASC,UAAUC,WAA6B;QACrD,IAAMJ,QAAQI;QACd,IAAIA,eAAeb,YAAYL,QAAQc,SAASA,QAAQ,MAAMR,SAASC,WAAW;QAClF,IAAIS,cAAc;QAClBA,eAAe;QAEf,IAAIP,UAAU;QACd,MAAOH,QAAQG,OAAO,GAAGH,QAAQa,WAAW,CAAE;YAC5C,IAAIb,QAAQE,IAAI,IAAIF,QAAQc,IAAI,CAACX,YAAY;YAC7C,IAAIH,QAAQe,KAAK,IAAIf,QAAQgB,KAAK,EAAE,OAAOjB,YAAY,MAAMC,SAASC;YACtED,QAAQe,KAAK;YACbf,QAAQG,OAAO;YAEfM,KAAK,SAACd,KAAKsB;gBACT,IAAItB,OAAOsB,UAAU,MAAM;oBACzB,OAAO,CAACb,cAAcT,KAAK,OAAOK,SAASC,aAAa,CAACS,eAAeC,cAAcd;gBACxF;gBACAS,oBAAM,CAACY,aAAa,CAAClB,QAAQmB,IAAI,EAAEnB,QAAQoB,SAAS,EAAEH,OAAO,SAACtB,KAAKU;2BAAU,CAACD,cAAcT,KAAKU,MAAML,SAASC,aAAa,CAACS,eAAeC,cAAcd;;YAC7J;QACF;QAEAa,eAAe;IACjB;AACF"}
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/iterators/stack-base-iterator/src/createProcessor.ts"],"sourcesContent":["import compat from 'async-compat';\n\nimport type { EachDoneCallback, Next, Processor, ProcessorOptions } from './types.js';\n\nconst isError = (err?: Error): boolean => err && err.stack !== undefined && err.message !== undefined;\n\nfunction processDone<T>(err: Error, options: ProcessorOptions<T>, callback: EachDoneCallback) {\n  // mark this iteration done\n  options.err = options.err || err;\n  options.done = true;\n\n  // process done\n  if (!options.done || options.counter > 0) return false;\n  callback(options.err, options.done);\n  return true;\n}\n\nfunction processResult(err, keep, options, callback) {\n  options.counter--;\n\n  // mark this iteration done\n  if ((err && compat.defaultValue(options.error(err), false)) || (!err && !compat.defaultValue(keep, true))) {\n    options.err = options.err || err;\n    options.done = true;\n  }\n\n  // process done\n  if (!options.done || options.counter > 0) return false;\n  callback(options.err, options.done);\n  return true;\n}\n\nexport default function createProcessor<T>(next: Next<T>, options: ProcessorOptions<T>, callback: EachDoneCallback): Processor {\n  let isProcessing = false;\n  return function processor(doneOrError?: Error | boolean): undefined {\n    const error = doneOrError as Error;\n    if (doneOrError && processDone(isError(error) ? error : null, options, callback)) return;\n    if (isProcessing) return;\n    isProcessing = true;\n\n    let counter = 0;\n    while (options.counter < options.concurrency) {\n      if (options.done || options.stop(counter++)) break;\n      if (options.total >= options.limit) {\n        processDone(null, options, callback);\n        return;\n      }\n      options.total++;\n      options.counter++;\n\n      next((err?: Error, value?: unknown) => {\n        if (err || value === null) {\n          return !processResult(err, false, options, callback) && !isProcessing ? processor() : undefined;\n        }\n        compat.asyncFunction(options.each, options.callbacks, value, (err, keep) => (!processResult(err, keep, options, callback) && !isProcessing ? processor() : undefined));\n      });\n    }\n\n    isProcessing = false;\n  };\n}\n"],"names":["createProcessor","isError","err","stack","undefined","message","processDone","options","callback","done","counter","processResult","keep","compat","defaultValue","error","next","isProcessing","processor","doneOrError","concurrency","stop","total","limit","value","asyncFunction","each","callbacks"],"mappings":";;;;+BAgCA;;;eAAwBA;;;kEAhCL;;;;;;AAInB,IAAMC,UAAU,SAACC;WAAyBA,OAAOA,IAAIC,KAAK,KAAKC,aAAaF,IAAIG,OAAO,KAAKD;;AAE5F,SAASE,YAAeJ,GAAU,EAAEK,OAA4B,EAAEC,QAA0B;IAC1F,2BAA2B;IAC3BD,QAAQL,GAAG,GAAGK,QAAQL,GAAG,IAAIA;IAC7BK,QAAQE,IAAI,GAAG;IAEf,eAAe;IACf,IAAI,CAACF,QAAQE,IAAI,IAAIF,QAAQG,OAAO,GAAG,GAAG,OAAO;IACjDF,SAASD,QAAQL,GAAG,EAAEK,QAAQE,IAAI;IAClC,OAAO;AACT;AAEA,SAASE,cAAcT,GAAG,EAAEU,IAAI,EAAEL,OAAO,EAAEC,QAAQ;IACjDD,QAAQG,OAAO;IAEf,2BAA2B;IAC3B,IAAI,AAACR,OAAOW,oBAAM,CAACC,YAAY,CAACP,QAAQQ,KAAK,CAACb,MAAM,UAAY,CAACA,OAAO,CAACW,oBAAM,CAACC,YAAY,CAACF,MAAM,OAAQ;QACzGL,QAAQL,GAAG,GAAGK,QAAQL,GAAG,IAAIA;QAC7BK,QAAQE,IAAI,GAAG;IACjB;IAEA,eAAe;IACf,IAAI,CAACF,QAAQE,IAAI,IAAIF,QAAQG,OAAO,GAAG,GAAG,OAAO;IACjDF,SAASD,QAAQL,GAAG,EAAEK,QAAQE,IAAI;IAClC,OAAO;AACT;AAEe,SAAST,gBAAmBgB,IAAa,EAAET,OAA4B,EAAEC,QAA0B;IAChH,IAAIS,eAAe;IACnB,OAAO,SAASC,UAAUC,WAA6B;QACrD,IAAMJ,QAAQI;QACd,IAAIA,eAAeb,YAAYL,QAAQc,SAASA,QAAQ,MAAMR,SAASC,WAAW;QAClF,IAAIS,cAAc;QAClBA,eAAe;QAEf,IAAIP,UAAU;QACd,MAAOH,QAAQG,OAAO,GAAGH,QAAQa,WAAW,CAAE;YAC5C,IAAIb,QAAQE,IAAI,IAAIF,QAAQc,IAAI,CAACX,YAAY;YAC7C,IAAIH,QAAQe,KAAK,IAAIf,QAAQgB,KAAK,EAAE;gBAClCjB,YAAY,MAAMC,SAASC;gBAC3B;YACF;YACAD,QAAQe,KAAK;YACbf,QAAQG,OAAO;YAEfM,KAAK,SAACd,KAAasB;gBACjB,IAAItB,OAAOsB,UAAU,MAAM;oBACzB,OAAO,CAACb,cAAcT,KAAK,OAAOK,SAASC,aAAa,CAACS,eAAeC,cAAcd;gBACxF;gBACAS,oBAAM,CAACY,aAAa,CAAClB,QAAQmB,IAAI,EAAEnB,QAAQoB,SAAS,EAAEH,OAAO,SAACtB,KAAKU;2BAAU,CAACD,cAAcT,KAAKU,MAAML,SAASC,aAAa,CAACS,eAAeC,cAAcd;;YAC7J;QACF;QAEAa,eAAe;IACjB;AACF"}

dist/cjs/index.d.cts

 import LinkedList from './LinkedList.js';
-import type { EachFunction, ForEachOptions, ProcessCallback, Processor, StackFunction, StackOptions } from './types.js';
+import type { EachDoneCallback, EachFunction, ForEachOptions, ProcessCallback, Processor, StackFunction, StackOptions } from './types.js';
 export type * from './types.js';
@@ -9,4 +9,4 @@ export { default as LinkedList } from './LinkedList.js';
     protected processors: LinkedList<Processor>;
-    protected queued: LinkedList<ProcessCallback>;
-    protected processing: LinkedList<ProcessCallback>;
+    protected queued: LinkedList<ProcessCallback<T>>;
+    protected processing: LinkedList<ProcessCallback<T>>;
     protected options: StackOptions;
@@ -19,5 +19,5 @@ protected entries: LinkedList<T>;
     next(...[value]: [] | [unknown]): Promise<IteratorResult<T, unknown>>;
-    forEach(fn: EachFunction<T>, options?: ForEachOptions | ProcessCallback, callback?: ProcessCallback): undefined | Promise<boolean>;
+    forEach(fn: EachFunction<T>, options?: ForEachOptions | ProcessCallback<T>, callback?: EachDoneCallback): undefined | Promise<boolean>;
     end(err?: Error): void;
     destroy(err?: Error): void;
 }

dist/cjs/index.d.ts

 import LinkedList from './LinkedList.js';
-import type { EachFunction, ForEachOptions, ProcessCallback, Processor, StackFunction, StackOptions } from './types.js';
+import type { EachDoneCallback, EachFunction, ForEachOptions, ProcessCallback, Processor, StackFunction, StackOptions } from './types.js';
 export type * from './types.js';
@@ -9,4 +9,4 @@ export { default as LinkedList } from './LinkedList.js';
     protected processors: LinkedList<Processor>;
-    protected queued: LinkedList<ProcessCallback>;
-    protected processing: LinkedList<ProcessCallback>;
+    protected queued: LinkedList<ProcessCallback<T>>;
+    protected processing: LinkedList<ProcessCallback<T>>;
     protected options: StackOptions;
@@ -19,5 +19,5 @@ protected entries: LinkedList<T>;
     next(...[value]: [] | [unknown]): Promise<IteratorResult<T, unknown>>;
-    forEach(fn: EachFunction<T>, options?: ForEachOptions | ProcessCallback, callback?: ProcessCallback): undefined | Promise<boolean>;
+    forEach(fn: EachFunction<T>, options?: ForEachOptions | ProcessCallback<T>, callback?: EachDoneCallback): undefined | Promise<boolean>;
     end(err?: Error): void;
     destroy(err?: Error): void;
 }

dist/cjs/index.js

@@ -140,3 +140,6 @@ "use strict";
         var callback = value;
-        if (typeof callback === 'function') return (0, _processOrQueue.default)(this, (0, _calloncefn.default)(callback));
+        if (typeof callback === 'function') {
+            (0, _processOrQueue.default)(this, (0, _calloncefn.default)(callback));
+            return;
+        }
         return new Promise(function(resolve, reject) {
@@ -143,0 +146,0 @@ _this.next(function(err, result) {

dist/cjs/index.js.map

@@ -1,1 +0,1 @@
-{"version":3,"sources":["/Users/kevin/Dev/OpenSource/iterators/stack-base-iterator/src/index.ts"],"sourcesContent":["import once from 'call-once-fn';\nimport LinkedList from './LinkedList.js';\n\nimport createProcesor from './createProcessor.js';\nimport drainStack from './drainStack.js';\nimport processOrQueue from './processOrQueue.js';\n\nimport type { AbstractIterator, EachFunction, ForEachOptions, ProcessCallback, Processor, ProcessorOptions, StackFunction, StackOptions } from './types.js';\n\nexport type * from './types.js';\nexport { default as LinkedList } from './LinkedList.js';\nexport default class StackBaseIterator<T> implements AsyncIterator<T> {\n  protected done: boolean;\n  protected stack: LinkedList<StackFunction<T>>;\n  protected processors: LinkedList<Processor>;\n  protected queued: LinkedList<ProcessCallback>;\n  protected processing: LinkedList<ProcessCallback>;\n\n  protected options: StackOptions;\n  protected entries: LinkedList<T>;\n  protected destroyed: boolean;\n\n  constructor(options: StackOptions = {}) {\n    this.options = { ...options };\n    this.options.error =\n      options.error ||\n      function defaultError(err) {\n        return !!err; // fail on errors\n      };\n\n    this.done = false;\n    this.stack = new LinkedList<StackFunction<T>>();\n    this.processors = new LinkedList<Processor>();\n    this.queued = new LinkedList<ProcessCallback>();\n    this.processing = new LinkedList<ProcessCallback>();\n    this.entries = new LinkedList<T>();\n  }\n\n  isDone() {\n    return this.done;\n  }\n\n  push(fn: StackFunction<T>) {\n    if (this.done) return console.log('Attempting to push on a done iterator');\n    this.stack.push(fn);\n    drainStack<T>(this as unknown as AbstractIterator<T>);\n  }\n\n  next(...[value]: [] | [unknown]): Promise<IteratorResult<T, unknown>> {\n    const callback = value as ProcessCallback;\n    if (typeof callback === 'function') return processOrQueue(this as unknown as AbstractIterator<T>, once(callback));\n\n    return new Promise((resolve, reject) => {\n      this.next((err, result) => (err ? reject(err) : resolve(result)));\n    });\n  }\n\n  forEach(fn: EachFunction<T>, options?: ForEachOptions | ProcessCallback, callback?: ProcessCallback): undefined | Promise<boolean> {\n    if (typeof fn !== 'function') throw new Error('Missing each function');\n    if (typeof options === 'function') {\n      callback = options as ProcessCallback;\n      options = {};\n    }\n\n    if (typeof callback === 'function') {\n      if (this.done) {\n        callback(null, true);\n        return;\n      }\n      options = options || {};\n      const processorOptions: ProcessorOptions<T> = {\n        each: fn,\n        callbacks: options.callbacks || false,\n        concurrency: options.concurrency || 1,\n        limit: options.limit || Infinity,\n        error:\n          options.error ||\n          function defaultError() {\n            return true; // default is exit on error\n          },\n        total: 0,\n        counter: 0,\n        stop: () => {\n          return this.done || this.queued.length >= this.stack.length;\n        },\n      };\n\n      let processor = createProcesor<T>(this.next.bind(this), processorOptions, (err) => {\n        if (!this.destroyed) this.processors.removeValue(processor);\n        processor = null;\n        options = null;\n        const done = !this.stack.length;\n        if ((err || done) && !this.done) this.end(err);\n        return callback(err, this.done || done);\n      });\n      this.processors.push(processor);\n      processor();\n      return;\n    }\n\n    return new Promise((resolve, reject) =>\n      this.forEach(fn, options, (err?: Error, done?: boolean) => {\n        err ? reject(err) : resolve(done);\n      })\n    );\n  }\n\n  end(err?: Error) {\n    if (this.done) return;\n    this.done = true;\n    while (this.processors.length > 0) this.processors.pop()(err || true);\n    while (this.processing.length > 0) err ? this.processing.pop()(err) : this.processing.pop()(null, null);\n    while (this.queued.length > 0) err ? this.queued.pop()(err) : this.queued.pop()(null, null);\n    while (this.stack.length > 0) this.stack.pop();\n  }\n\n  destroy(err?: Error) {\n    if (this.destroyed) throw new Error('Already destroyed');\n    this.destroyed = true;\n    this.end(err);\n  }\n}\n\nif (typeof Symbol !== 'undefined' && Symbol.asyncIterator) {\n  StackBaseIterator.prototype[Symbol.asyncIterator] = function asyncIterator() {\n    const self = this;\n    return {\n      next: function next() {\n        return self.next().then(function nextCallback(value) {\n          return Promise.resolve({ value: value, done: value === null });\n        });\n      },\n      destroy: function destroy() {\n        self.destroy();\n        return Promise.resolve();\n      },\n    };\n  };\n}\n"],"names":["LinkedList","StackBaseIterator","options","error","defaultError","err","done","stack","processors","queued","processing","entries","isDone","push","fn","console","log","drainStack","next","value","callback","processOrQueue","once","Promise","resolve","reject","result","forEach","Error","processorOptions","each","callbacks","concurrency","limit","Infinity","total","counter","stop","length","processor","createProcesor","bind","destroyed","removeValue","end","pop","destroy","Symbol","asyncIterator","prototype","self","then","nextCallback"],"mappings":"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"}
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/iterators/stack-base-iterator/src/index.ts"],"sourcesContent":["import once from 'call-once-fn';\nimport LinkedList from './LinkedList.js';\n\nimport createProcesor from './createProcessor.js';\nimport drainStack from './drainStack.js';\nimport processOrQueue from './processOrQueue.js';\n\nimport type { AbstractIterator, EachDoneCallback, EachFunction, ForEachOptions, ProcessCallback, Processor, ProcessorOptions, StackFunction, StackOptions } from './types.js';\n\nexport type * from './types.js';\nexport { default as LinkedList } from './LinkedList.js';\nexport default class StackBaseIterator<T> implements AsyncIterator<T> {\n  protected done: boolean;\n  protected stack: LinkedList<StackFunction<T>>;\n  protected processors: LinkedList<Processor>;\n  protected queued: LinkedList<ProcessCallback<T>>;\n  protected processing: LinkedList<ProcessCallback<T>>;\n\n  protected options: StackOptions;\n  protected entries: LinkedList<T>;\n  protected destroyed: boolean;\n\n  constructor(options: StackOptions = {}) {\n    this.options = { ...options };\n    this.options.error =\n      options.error ||\n      function defaultError(err) {\n        return !!err; // fail on errors\n      };\n\n    this.done = false;\n    this.stack = new LinkedList<StackFunction<T>>();\n    this.processors = new LinkedList<Processor>();\n    this.queued = new LinkedList<ProcessCallback<T>>();\n    this.processing = new LinkedList<ProcessCallback<T>>();\n    this.entries = new LinkedList<T>();\n  }\n\n  isDone() {\n    return this.done;\n  }\n\n  push(fn: StackFunction<T>) {\n    if (this.done) return console.log('Attempting to push on a done iterator');\n    this.stack.push(fn);\n    drainStack<T>(this as unknown as AbstractIterator<T>);\n  }\n\n  next(...[value]: [] | [unknown]): Promise<IteratorResult<T, unknown>> {\n    const callback = value as ProcessCallback<T>;\n    if (typeof callback === 'function') {\n      processOrQueue(this as unknown as AbstractIterator<T>, once(callback) as ProcessCallback<T>);\n      return;\n    }\n\n    return new Promise((resolve, reject) => {\n      this.next((err, result) => (err ? reject(err) : resolve(result)));\n    });\n  }\n\n  forEach(fn: EachFunction<T>, options?: ForEachOptions | ProcessCallback<T>, callback?: EachDoneCallback): undefined | Promise<boolean> {\n    if (typeof fn !== 'function') throw new Error('Missing each function');\n    if (typeof options === 'function') {\n      callback = options as EachDoneCallback;\n      options = {};\n    }\n\n    if (typeof callback === 'function') {\n      if (this.done) {\n        callback(null, true);\n        return;\n      }\n      options = options || {};\n      const processorOptions: ProcessorOptions<T> = {\n        each: fn,\n        callbacks: options.callbacks || false,\n        concurrency: options.concurrency || 1,\n        limit: options.limit || Infinity,\n        error:\n          options.error ||\n          function defaultError() {\n            return true; // default is exit on error\n          },\n        total: 0,\n        counter: 0,\n        stop: () => {\n          return this.done || this.queued.length >= this.stack.length;\n        },\n      };\n\n      let processor = createProcesor<T>(this.next.bind(this), processorOptions, (err) => {\n        if (!this.destroyed) this.processors.removeValue(processor);\n        processor = null;\n        options = null;\n        const done = !this.stack.length;\n        if ((err || done) && !this.done) this.end(err);\n        return callback(err, this.done || done);\n      });\n      this.processors.push(processor);\n      processor();\n      return;\n    }\n\n    return new Promise((resolve, reject) =>\n      this.forEach(fn, options, (err?: Error, done?: boolean) => {\n        err ? reject(err) : resolve(done);\n      })\n    );\n  }\n\n  end(err?: Error) {\n    if (this.done) return;\n    this.done = true;\n    while (this.processors.length > 0) this.processors.pop()(err || true);\n    while (this.processing.length > 0) err ? this.processing.pop()(err) : this.processing.pop()(null, null);\n    while (this.queued.length > 0) err ? this.queued.pop()(err) : this.queued.pop()(null, null);\n    while (this.stack.length > 0) this.stack.pop();\n  }\n\n  destroy(err?: Error) {\n    if (this.destroyed) throw new Error('Already destroyed');\n    this.destroyed = true;\n    this.end(err);\n  }\n}\n\nif (typeof Symbol !== 'undefined' && Symbol.asyncIterator) {\n  StackBaseIterator.prototype[Symbol.asyncIterator] = function asyncIterator() {\n    const self = this;\n    return {\n      next: function next() {\n        return self.next().then(function nextCallback(value) {\n          return Promise.resolve({ value: value, done: value === null });\n        });\n      },\n      destroy: function destroy() {\n        self.destroy();\n        return Promise.resolve();\n      },\n    };\n  };\n}\n"],"names":["LinkedList","StackBaseIterator","options","error","defaultError","err","done","stack","processors","queued","processing","entries","isDone","push","fn","console","log","drainStack","next","value","callback","processOrQueue","once","Promise","resolve","reject","result","forEach","Error","processorOptions","each","callbacks","concurrency","limit","Infinity","total","counter","stop","length","processor","createProcesor","bind","destroyed","removeValue","end","pop","destroy","Symbol","asyncIterator","prototype","self","then","nextCallback"],"mappings":"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"}

dist/cjs/processOrQueue.d.cts

@@ -1,2 +0,2 @@
-import type { AbstractIterator, EachCallback } from './types.js';
-export default function processOrQueue<T>(iterator: AbstractIterator<T>, callback: EachCallback): undefined;
+import type { AbstractIterator, ProcessCallback } from './types.js';
+export default function processOrQueue<T>(iterator: AbstractIterator<T>, callback: ProcessCallback<T>): undefined;

dist/cjs/processOrQueue.d.ts

@@ -1,2 +0,2 @@
-import type { AbstractIterator, EachCallback } from './types.js';
-export default function processOrQueue<T>(iterator: AbstractIterator<T>, callback: EachCallback): undefined;
+import type { AbstractIterator, ProcessCallback } from './types.js';
+export default function processOrQueue<T>(iterator: AbstractIterator<T>, callback: ProcessCallback<T>): undefined;

dist/cjs/processOrQueue.js.map

@@ -1,1 +0,1 @@
-{"version":3,"sources":["/Users/kevin/Dev/OpenSource/iterators/stack-base-iterator/src/processOrQueue.ts"],"sourcesContent":["import compat from 'async-compat';\n\nimport asap from 'asap';\n\nimport type { AbstractIterator, EachCallback } from './types.js';\n\nexport default function processOrQueue<T>(iterator: AbstractIterator<T>, callback: EachCallback): undefined {\n  if (iterator.done) {\n    callback(null, null);\n    return;\n  }\n\n  // nothing to process so queue\n  if (!iterator.stack.length) {\n    iterator.queued.unshift(callback);\n    return;\n  }\n\n  // process next\n  const next = iterator.stack.pop();\n  iterator.processing.push(callback);\n  next(iterator, (err?: Error, result?: T) => {\n    // break call stack\n    asap(() => {\n      // done is based on stack being empty and not error state as the user may choose to skip the error\n      iterator.processing.removeValue(callback);\n      if (iterator.done) return callback(null, null); // early exit\n      if (err && compat.defaultValue(iterator.options.error(err), true)) err = null; // skip error\n\n      const done = iterator.stack.length <= 0 && iterator.processing.length <= 0;\n      !done && !err && !result ? processOrQueue<T>(iterator, callback) : callback(err, result || null);\n      if (done && !iterator.done) iterator.end(); // end\n    });\n  });\n}\n"],"names":["processOrQueue","iterator","callback","done","stack","length","queued","unshift","next","pop","processing","push","err","result","asap","removeValue","compat","defaultValue","options","error","end"],"mappings":";;;;+BAMA;;;eAAwBA;;;kEANL;2DAEF;;;;;;AAIF,SAASA,eAAkBC,QAA6B,EAAEC,QAAsB;IAC7F,IAAID,SAASE,IAAI,EAAE;QACjBD,SAAS,MAAM;QACf;IACF;IAEA,8BAA8B;IAC9B,IAAI,CAACD,SAASG,KAAK,CAACC,MAAM,EAAE;QAC1BJ,SAASK,MAAM,CAACC,OAAO,CAACL;QACxB;IACF;IAEA,eAAe;IACf,IAAMM,OAAOP,SAASG,KAAK,CAACK,GAAG;IAC/BR,SAASS,UAAU,CAACC,IAAI,CAACT;IACzBM,KAAKP,UAAU,SAACW,KAAaC;QAC3B,mBAAmB;QACnBC,IAAAA,aAAI,EAAC;YACH,kGAAkG;YAClGb,SAASS,UAAU,CAACK,WAAW,CAACb;YAChC,IAAID,SAASE,IAAI,EAAE,OAAOD,SAAS,MAAM,OAAO,aAAa;YAC7D,IAAIU,OAAOI,oBAAM,CAACC,YAAY,CAAChB,SAASiB,OAAO,CAACC,KAAK,CAACP,MAAM,OAAOA,MAAM,MAAM,aAAa;YAE5F,IAAMT,OAAOF,SAASG,KAAK,CAACC,MAAM,IAAI,KAAKJ,SAASS,UAAU,CAACL,MAAM,IAAI;YACzE,CAACF,QAAQ,CAACS,OAAO,CAACC,SAASb,eAAkBC,UAAUC,YAAYA,SAASU,KAAKC,UAAU;YAC3F,IAAIV,QAAQ,CAACF,SAASE,IAAI,EAAEF,SAASmB,GAAG,IAAI,MAAM;QACpD;IACF;AACF"}
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/iterators/stack-base-iterator/src/processOrQueue.ts"],"sourcesContent":["import compat from 'async-compat';\n\nimport asap from 'asap';\n\nimport type { AbstractIterator, ProcessCallback } from './types.js';\n\nexport default function processOrQueue<T>(iterator: AbstractIterator<T>, callback: ProcessCallback<T>): undefined {\n  if (iterator.done) {\n    callback(null, null);\n    return;\n  }\n\n  // nothing to process so queue\n  if (!iterator.stack.length) {\n    iterator.queued.unshift(callback);\n    return;\n  }\n\n  // process next\n  const next = iterator.stack.pop();\n  iterator.processing.push(callback);\n  next(iterator, (err?: Error, result?: T): undefined => {\n    // break call stack\n    asap(() => {\n      // done is based on stack being empty and not error state as the user may choose to skip the error\n      iterator.processing.removeValue(callback);\n      if (iterator.done) return callback(null, null); // early exit\n      if (err && compat.defaultValue(iterator.options.error(err), true)) err = null; // skip error\n\n      const done = iterator.stack.length <= 0 && iterator.processing.length <= 0;\n      !done && !err && !result ? processOrQueue<T>(iterator, callback) : callback(err, result || null);\n      if (done && !iterator.done) iterator.end(); // end\n    });\n  });\n}\n"],"names":["processOrQueue","iterator","callback","done","stack","length","queued","unshift","next","pop","processing","push","err","result","asap","removeValue","compat","defaultValue","options","error","end"],"mappings":";;;;+BAMA;;;eAAwBA;;;kEANL;2DAEF;;;;;;AAIF,SAASA,eAAkBC,QAA6B,EAAEC,QAA4B;IACnG,IAAID,SAASE,IAAI,EAAE;QACjBD,SAAS,MAAM;QACf;IACF;IAEA,8BAA8B;IAC9B,IAAI,CAACD,SAASG,KAAK,CAACC,MAAM,EAAE;QAC1BJ,SAASK,MAAM,CAACC,OAAO,CAACL;QACxB;IACF;IAEA,eAAe;IACf,IAAMM,OAAOP,SAASG,KAAK,CAACK,GAAG;IAC/BR,SAASS,UAAU,CAACC,IAAI,CAACT;IACzBM,KAAKP,UAAU,SAACW,KAAaC;QAC3B,mBAAmB;QACnBC,IAAAA,aAAI,EAAC;YACH,kGAAkG;YAClGb,SAASS,UAAU,CAACK,WAAW,CAACb;YAChC,IAAID,SAASE,IAAI,EAAE,OAAOD,SAAS,MAAM,OAAO,aAAa;YAC7D,IAAIU,OAAOI,oBAAM,CAACC,YAAY,CAAChB,SAASiB,OAAO,CAACC,KAAK,CAACP,MAAM,OAAOA,MAAM,MAAM,aAAa;YAE5F,IAAMT,OAAOF,SAASG,KAAK,CAACC,MAAM,IAAI,KAAKJ,SAASS,UAAU,CAACL,MAAM,IAAI;YACzE,CAACF,QAAQ,CAACS,OAAO,CAACC,SAASb,eAAkBC,UAAUC,YAAYA,SAASU,KAAKC,UAAU;YAC3F,IAAIV,QAAQ,CAACF,SAASE,IAAI,EAAEF,SAASmB,GAAG,IAAI,MAAM;QACpD;IACF;AACF"}

dist/cjs/types.d.cts

 import type LinkedList from './LinkedList.js';
-export type ProcessCallback = (error?: Error, done?: boolean) => void;
-export type Processor = (doneOrError?: Error | boolean) => void;
-export type EachCallback = (error?: Error, value?: unknown) => void;
-export type EachFunctionCallback<T> = (value: T, callback: EachCallback) => undefined;
-export type EachFunctionPromise<T> = (value: T) => Promise<unknown>;
-export type EachFunction<T> = EachFunctionCallback<T> | EachFunctionPromise<T>;
-export type Next = (value: EachCallback) => void;
+export type ProcessCallback<T> = (error?: Error, value?: T | null) => undefined;
+export type Processor = (doneOrError?: Error | boolean) => undefined;
+export type EachDoneCallback = (error?: Error, value?: boolean) => undefined;
+export type EachCallback<T> = (value: T, callback: EachDoneCallback) => undefined;
+export type EachPromise<T> = (value: T) => Promise<boolean>;
+export type EachFunction<T> = EachCallback<T> | EachPromise<T>;
+export type ValueCallback<T> = (error?: Error, value?: T) => boolean;
+export type Next<T> = (callback: ProcessCallback<T>) => undefined;
 export interface StackOptions {
@@ -26,3 +27,3 @@ error?: (err: NodeJS.ErrnoException) => boolean;
 }
-export type StackFunction<T> = (iterator: AbstractIterator<T>, callback: EachCallback) => void;
+export type StackFunction<T> = (iterator: AbstractIterator<T>, callback: ValueCallback<T>) => void;
 export interface AbstractIterator<T> {
@@ -32,6 +33,6 @@ done: boolean;
     processors: LinkedList<Processor>;
-    queued: LinkedList<ProcessCallback>;
-    processing: LinkedList<ProcessCallback>;
+    queued: LinkedList<ProcessCallback<T>>;
+    processing: LinkedList<ProcessCallback<T>>;
     options: StackOptions;
     end: () => undefined;
 }

dist/cjs/types.d.ts

 import type LinkedList from './LinkedList.js';
-export type ProcessCallback = (error?: Error, done?: boolean) => void;
-export type Processor = (doneOrError?: Error | boolean) => void;
-export type EachCallback = (error?: Error, value?: unknown) => void;
-export type EachFunctionCallback<T> = (value: T, callback: EachCallback) => undefined;
-export type EachFunctionPromise<T> = (value: T) => Promise<unknown>;
-export type EachFunction<T> = EachFunctionCallback<T> | EachFunctionPromise<T>;
-export type Next = (value: EachCallback) => void;
+export type ProcessCallback<T> = (error?: Error, value?: T | null) => undefined;
+export type Processor = (doneOrError?: Error | boolean) => undefined;
+export type EachDoneCallback = (error?: Error, value?: boolean) => undefined;
+export type EachCallback<T> = (value: T, callback: EachDoneCallback) => undefined;
+export type EachPromise<T> = (value: T) => Promise<boolean>;
+export type EachFunction<T> = EachCallback<T> | EachPromise<T>;
+export type ValueCallback<T> = (error?: Error, value?: T) => boolean;
+export type Next<T> = (callback: ProcessCallback<T>) => undefined;
 export interface StackOptions {
@@ -26,3 +27,3 @@ error?: (err: NodeJS.ErrnoException) => boolean;
 }
-export type StackFunction<T> = (iterator: AbstractIterator<T>, callback: EachCallback) => void;
+export type StackFunction<T> = (iterator: AbstractIterator<T>, callback: ValueCallback<T>) => void;
 export interface AbstractIterator<T> {
@@ -32,6 +33,6 @@ done: boolean;
     processors: LinkedList<Processor>;
-    queued: LinkedList<ProcessCallback>;
-    processing: LinkedList<ProcessCallback>;
+    queued: LinkedList<ProcessCallback<T>>;
+    processing: LinkedList<ProcessCallback<T>>;
     options: StackOptions;
     end: () => undefined;
 }

dist/esm/createProcessor.d.ts

@@ -1,2 +0,2 @@
-import type { Next, ProcessCallback, Processor, ProcessorOptions } from './types.js';
-export default function createProcessor<T>(next: Next, options: ProcessorOptions<T>, callback: ProcessCallback): Processor;
+import type { EachDoneCallback, Next, Processor, ProcessorOptions } from './types.js';
+export default function createProcessor<T>(next: Next<T>, options: ProcessorOptions<T>, callback: EachDoneCallback): Processor;

dist/esm/createProcessor.js

@@ -34,3 +34,6 @@ import compat from 'async-compat';
             if (options.done || options.stop(counter++)) break;
-            if (options.total >= options.limit) return processDone(null, options, callback);
+            if (options.total >= options.limit) {
+                processDone(null, options, callback);
+                return;
+            }
             options.total++;
@@ -37,0 +40,0 @@ options.counter++;

dist/esm/createProcessor.js.map

@@ -1,1 +0,1 @@
-{"version":3,"sources":["/Users/kevin/Dev/OpenSource/iterators/stack-base-iterator/src/createProcessor.ts"],"sourcesContent":["import compat from 'async-compat';\n\nimport type { Next, ProcessCallback, Processor, ProcessorOptions } from './types.js';\n\nconst isError = (err?: Error): boolean => err && err.stack !== undefined && err.message !== undefined;\n\nfunction processDone<T>(err: Error, options: ProcessorOptions<T>, callback: ProcessCallback) {\n  // mark this iteration done\n  options.err = options.err || err;\n  options.done = true;\n\n  // process done\n  if (!options.done || options.counter > 0) return false;\n  callback(options.err, options.done);\n  return true;\n}\n\nfunction processResult(err, keep, options, callback) {\n  options.counter--;\n\n  // mark this iteration done\n  if ((err && compat.defaultValue(options.error(err), false)) || (!err && !compat.defaultValue(keep, true))) {\n    options.err = options.err || err;\n    options.done = true;\n  }\n\n  // process done\n  if (!options.done || options.counter > 0) return false;\n  callback(options.err, options.done);\n  return true;\n}\n\nexport default function createProcessor<T>(next: Next, options: ProcessorOptions<T>, callback: ProcessCallback): Processor {\n  let isProcessing = false;\n  return function processor(doneOrError?: Error | boolean) {\n    const error = doneOrError as Error;\n    if (doneOrError && processDone(isError(error) ? error : null, options, callback)) return;\n    if (isProcessing) return;\n    isProcessing = true;\n\n    let counter = 0;\n    while (options.counter < options.concurrency) {\n      if (options.done || options.stop(counter++)) break;\n      if (options.total >= options.limit) return processDone(null, options, callback);\n      options.total++;\n      options.counter++;\n\n      next((err, value) => {\n        if (err || value === null) {\n          return !processResult(err, false, options, callback) && !isProcessing ? processor() : undefined;\n        }\n        compat.asyncFunction(options.each, options.callbacks, value, (err, keep) => (!processResult(err, keep, options, callback) && !isProcessing ? processor() : undefined));\n      });\n    }\n\n    isProcessing = false;\n  };\n}\n"],"names":["compat","isError","err","stack","undefined","message","processDone","options","callback","done","counter","processResult","keep","defaultValue","error","createProcessor","next","isProcessing","processor","doneOrError","concurrency","stop","total","limit","value","asyncFunction","each","callbacks"],"mappings":"AAAA,OAAOA,YAAY,eAAe;AAIlC,MAAMC,UAAU,CAACC,MAAyBA,OAAOA,IAAIC,KAAK,KAAKC,aAAaF,IAAIG,OAAO,KAAKD;AAE5F,SAASE,YAAeJ,GAAU,EAAEK,OAA4B,EAAEC,QAAyB;IACzF,2BAA2B;IAC3BD,QAAQL,GAAG,GAAGK,QAAQL,GAAG,IAAIA;IAC7BK,QAAQE,IAAI,GAAG;IAEf,eAAe;IACf,IAAI,CAACF,QAAQE,IAAI,IAAIF,QAAQG,OAAO,GAAG,GAAG,OAAO;IACjDF,SAASD,QAAQL,GAAG,EAAEK,QAAQE,IAAI;IAClC,OAAO;AACT;AAEA,SAASE,cAAcT,GAAG,EAAEU,IAAI,EAAEL,OAAO,EAAEC,QAAQ;IACjDD,QAAQG,OAAO;IAEf,2BAA2B;IAC3B,IAAI,AAACR,OAAOF,OAAOa,YAAY,CAACN,QAAQO,KAAK,CAACZ,MAAM,UAAY,CAACA,OAAO,CAACF,OAAOa,YAAY,CAACD,MAAM,OAAQ;QACzGL,QAAQL,GAAG,GAAGK,QAAQL,GAAG,IAAIA;QAC7BK,QAAQE,IAAI,GAAG;IACjB;IAEA,eAAe;IACf,IAAI,CAACF,QAAQE,IAAI,IAAIF,QAAQG,OAAO,GAAG,GAAG,OAAO;IACjDF,SAASD,QAAQL,GAAG,EAAEK,QAAQE,IAAI;IAClC,OAAO;AACT;AAEA,eAAe,SAASM,gBAAmBC,IAAU,EAAET,OAA4B,EAAEC,QAAyB;IAC5G,IAAIS,eAAe;IACnB,OAAO,SAASC,UAAUC,WAA6B;QACrD,MAAML,QAAQK;QACd,IAAIA,eAAeb,YAAYL,QAAQa,SAASA,QAAQ,MAAMP,SAASC,WAAW;QAClF,IAAIS,cAAc;QAClBA,eAAe;QAEf,IAAIP,UAAU;QACd,MAAOH,QAAQG,OAAO,GAAGH,QAAQa,WAAW,CAAE;YAC5C,IAAIb,QAAQE,IAAI,IAAIF,QAAQc,IAAI,CAACX,YAAY;YAC7C,IAAIH,QAAQe,KAAK,IAAIf,QAAQgB,KAAK,EAAE,OAAOjB,YAAY,MAAMC,SAASC;YACtED,QAAQe,KAAK;YACbf,QAAQG,OAAO;YAEfM,KAAK,CAACd,KAAKsB;gBACT,IAAItB,OAAOsB,UAAU,MAAM;oBACzB,OAAO,CAACb,cAAcT,KAAK,OAAOK,SAASC,aAAa,CAACS,eAAeC,cAAcd;gBACxF;gBACAJ,OAAOyB,aAAa,CAAClB,QAAQmB,IAAI,EAAEnB,QAAQoB,SAAS,EAAEH,OAAO,CAACtB,KAAKU,OAAU,CAACD,cAAcT,KAAKU,MAAML,SAASC,aAAa,CAACS,eAAeC,cAAcd;YAC7J;QACF;QAEAa,eAAe;IACjB;AACF"}
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/iterators/stack-base-iterator/src/createProcessor.ts"],"sourcesContent":["import compat from 'async-compat';\n\nimport type { EachDoneCallback, Next, Processor, ProcessorOptions } from './types.js';\n\nconst isError = (err?: Error): boolean => err && err.stack !== undefined && err.message !== undefined;\n\nfunction processDone<T>(err: Error, options: ProcessorOptions<T>, callback: EachDoneCallback) {\n  // mark this iteration done\n  options.err = options.err || err;\n  options.done = true;\n\n  // process done\n  if (!options.done || options.counter > 0) return false;\n  callback(options.err, options.done);\n  return true;\n}\n\nfunction processResult(err, keep, options, callback) {\n  options.counter--;\n\n  // mark this iteration done\n  if ((err && compat.defaultValue(options.error(err), false)) || (!err && !compat.defaultValue(keep, true))) {\n    options.err = options.err || err;\n    options.done = true;\n  }\n\n  // process done\n  if (!options.done || options.counter > 0) return false;\n  callback(options.err, options.done);\n  return true;\n}\n\nexport default function createProcessor<T>(next: Next<T>, options: ProcessorOptions<T>, callback: EachDoneCallback): Processor {\n  let isProcessing = false;\n  return function processor(doneOrError?: Error | boolean): undefined {\n    const error = doneOrError as Error;\n    if (doneOrError && processDone(isError(error) ? error : null, options, callback)) return;\n    if (isProcessing) return;\n    isProcessing = true;\n\n    let counter = 0;\n    while (options.counter < options.concurrency) {\n      if (options.done || options.stop(counter++)) break;\n      if (options.total >= options.limit) {\n        processDone(null, options, callback);\n        return;\n      }\n      options.total++;\n      options.counter++;\n\n      next((err?: Error, value?: unknown) => {\n        if (err || value === null) {\n          return !processResult(err, false, options, callback) && !isProcessing ? processor() : undefined;\n        }\n        compat.asyncFunction(options.each, options.callbacks, value, (err, keep) => (!processResult(err, keep, options, callback) && !isProcessing ? processor() : undefined));\n      });\n    }\n\n    isProcessing = false;\n  };\n}\n"],"names":["compat","isError","err","stack","undefined","message","processDone","options","callback","done","counter","processResult","keep","defaultValue","error","createProcessor","next","isProcessing","processor","doneOrError","concurrency","stop","total","limit","value","asyncFunction","each","callbacks"],"mappings":"AAAA,OAAOA,YAAY,eAAe;AAIlC,MAAMC,UAAU,CAACC,MAAyBA,OAAOA,IAAIC,KAAK,KAAKC,aAAaF,IAAIG,OAAO,KAAKD;AAE5F,SAASE,YAAeJ,GAAU,EAAEK,OAA4B,EAAEC,QAA0B;IAC1F,2BAA2B;IAC3BD,QAAQL,GAAG,GAAGK,QAAQL,GAAG,IAAIA;IAC7BK,QAAQE,IAAI,GAAG;IAEf,eAAe;IACf,IAAI,CAACF,QAAQE,IAAI,IAAIF,QAAQG,OAAO,GAAG,GAAG,OAAO;IACjDF,SAASD,QAAQL,GAAG,EAAEK,QAAQE,IAAI;IAClC,OAAO;AACT;AAEA,SAASE,cAAcT,GAAG,EAAEU,IAAI,EAAEL,OAAO,EAAEC,QAAQ;IACjDD,QAAQG,OAAO;IAEf,2BAA2B;IAC3B,IAAI,AAACR,OAAOF,OAAOa,YAAY,CAACN,QAAQO,KAAK,CAACZ,MAAM,UAAY,CAACA,OAAO,CAACF,OAAOa,YAAY,CAACD,MAAM,OAAQ;QACzGL,QAAQL,GAAG,GAAGK,QAAQL,GAAG,IAAIA;QAC7BK,QAAQE,IAAI,GAAG;IACjB;IAEA,eAAe;IACf,IAAI,CAACF,QAAQE,IAAI,IAAIF,QAAQG,OAAO,GAAG,GAAG,OAAO;IACjDF,SAASD,QAAQL,GAAG,EAAEK,QAAQE,IAAI;IAClC,OAAO;AACT;AAEA,eAAe,SAASM,gBAAmBC,IAAa,EAAET,OAA4B,EAAEC,QAA0B;IAChH,IAAIS,eAAe;IACnB,OAAO,SAASC,UAAUC,WAA6B;QACrD,MAAML,QAAQK;QACd,IAAIA,eAAeb,YAAYL,QAAQa,SAASA,QAAQ,MAAMP,SAASC,WAAW;QAClF,IAAIS,cAAc;QAClBA,eAAe;QAEf,IAAIP,UAAU;QACd,MAAOH,QAAQG,OAAO,GAAGH,QAAQa,WAAW,CAAE;YAC5C,IAAIb,QAAQE,IAAI,IAAIF,QAAQc,IAAI,CAACX,YAAY;YAC7C,IAAIH,QAAQe,KAAK,IAAIf,QAAQgB,KAAK,EAAE;gBAClCjB,YAAY,MAAMC,SAASC;gBAC3B;YACF;YACAD,QAAQe,KAAK;YACbf,QAAQG,OAAO;YAEfM,KAAK,CAACd,KAAasB;gBACjB,IAAItB,OAAOsB,UAAU,MAAM;oBACzB,OAAO,CAACb,cAAcT,KAAK,OAAOK,SAASC,aAAa,CAACS,eAAeC,cAAcd;gBACxF;gBACAJ,OAAOyB,aAAa,CAAClB,QAAQmB,IAAI,EAAEnB,QAAQoB,SAAS,EAAEH,OAAO,CAACtB,KAAKU,OAAU,CAACD,cAAcT,KAAKU,MAAML,SAASC,aAAa,CAACS,eAAeC,cAAcd;YAC7J;QACF;QAEAa,eAAe;IACjB;AACF"}

dist/esm/index.d.ts

 import LinkedList from './LinkedList.js';
-import type { EachFunction, ForEachOptions, ProcessCallback, Processor, StackFunction, StackOptions } from './types.js';
+import type { EachDoneCallback, EachFunction, ForEachOptions, ProcessCallback, Processor, StackFunction, StackOptions } from './types.js';
 export type * from './types.js';
@@ -9,4 +9,4 @@ export { default as LinkedList } from './LinkedList.js';
     protected processors: LinkedList<Processor>;
-    protected queued: LinkedList<ProcessCallback>;
-    protected processing: LinkedList<ProcessCallback>;
+    protected queued: LinkedList<ProcessCallback<T>>;
+    protected processing: LinkedList<ProcessCallback<T>>;
     protected options: StackOptions;
@@ -19,5 +19,5 @@ protected entries: LinkedList<T>;
     next(...[value]: [] | [unknown]): Promise<IteratorResult<T, unknown>>;
-    forEach(fn: EachFunction<T>, options?: ForEachOptions | ProcessCallback, callback?: ProcessCallback): undefined | Promise<boolean>;
+    forEach(fn: EachFunction<T>, options?: ForEachOptions | ProcessCallback<T>, callback?: EachDoneCallback): undefined | Promise<boolean>;
     end(err?: Error): void;
     destroy(err?: Error): void;
 }

dist/esm/index.js

@@ -18,3 +18,6 @@ import once from 'call-once-fn';
         const callback = value;
-        if (typeof callback === 'function') return processOrQueue(this, once(callback));
+        if (typeof callback === 'function') {
+            processOrQueue(this, once(callback));
+            return;
+        }
         return new Promise((resolve, reject)=>{
@@ -21,0 +24,0 @@ this.next((err, result)=>err ? reject(err) : resolve(result));

dist/esm/index.js.map

@@ -1,1 +0,1 @@
-{"version":3,"sources":["/Users/kevin/Dev/OpenSource/iterators/stack-base-iterator/src/index.ts"],"sourcesContent":["import once from 'call-once-fn';\nimport LinkedList from './LinkedList.js';\n\nimport createProcesor from './createProcessor.js';\nimport drainStack from './drainStack.js';\nimport processOrQueue from './processOrQueue.js';\n\nimport type { AbstractIterator, EachFunction, ForEachOptions, ProcessCallback, Processor, ProcessorOptions, StackFunction, StackOptions } from './types.js';\n\nexport type * from './types.js';\nexport { default as LinkedList } from './LinkedList.js';\nexport default class StackBaseIterator<T> implements AsyncIterator<T> {\n  protected done: boolean;\n  protected stack: LinkedList<StackFunction<T>>;\n  protected processors: LinkedList<Processor>;\n  protected queued: LinkedList<ProcessCallback>;\n  protected processing: LinkedList<ProcessCallback>;\n\n  protected options: StackOptions;\n  protected entries: LinkedList<T>;\n  protected destroyed: boolean;\n\n  constructor(options: StackOptions = {}) {\n    this.options = { ...options };\n    this.options.error =\n      options.error ||\n      function defaultError(err) {\n        return !!err; // fail on errors\n      };\n\n    this.done = false;\n    this.stack = new LinkedList<StackFunction<T>>();\n    this.processors = new LinkedList<Processor>();\n    this.queued = new LinkedList<ProcessCallback>();\n    this.processing = new LinkedList<ProcessCallback>();\n    this.entries = new LinkedList<T>();\n  }\n\n  isDone() {\n    return this.done;\n  }\n\n  push(fn: StackFunction<T>) {\n    if (this.done) return console.log('Attempting to push on a done iterator');\n    this.stack.push(fn);\n    drainStack<T>(this as unknown as AbstractIterator<T>);\n  }\n\n  next(...[value]: [] | [unknown]): Promise<IteratorResult<T, unknown>> {\n    const callback = value as ProcessCallback;\n    if (typeof callback === 'function') return processOrQueue(this as unknown as AbstractIterator<T>, once(callback));\n\n    return new Promise((resolve, reject) => {\n      this.next((err, result) => (err ? reject(err) : resolve(result)));\n    });\n  }\n\n  forEach(fn: EachFunction<T>, options?: ForEachOptions | ProcessCallback, callback?: ProcessCallback): undefined | Promise<boolean> {\n    if (typeof fn !== 'function') throw new Error('Missing each function');\n    if (typeof options === 'function') {\n      callback = options as ProcessCallback;\n      options = {};\n    }\n\n    if (typeof callback === 'function') {\n      if (this.done) {\n        callback(null, true);\n        return;\n      }\n      options = options || {};\n      const processorOptions: ProcessorOptions<T> = {\n        each: fn,\n        callbacks: options.callbacks || false,\n        concurrency: options.concurrency || 1,\n        limit: options.limit || Infinity,\n        error:\n          options.error ||\n          function defaultError() {\n            return true; // default is exit on error\n          },\n        total: 0,\n        counter: 0,\n        stop: () => {\n          return this.done || this.queued.length >= this.stack.length;\n        },\n      };\n\n      let processor = createProcesor<T>(this.next.bind(this), processorOptions, (err) => {\n        if (!this.destroyed) this.processors.removeValue(processor);\n        processor = null;\n        options = null;\n        const done = !this.stack.length;\n        if ((err || done) && !this.done) this.end(err);\n        return callback(err, this.done || done);\n      });\n      this.processors.push(processor);\n      processor();\n      return;\n    }\n\n    return new Promise((resolve, reject) =>\n      this.forEach(fn, options, (err?: Error, done?: boolean) => {\n        err ? reject(err) : resolve(done);\n      })\n    );\n  }\n\n  end(err?: Error) {\n    if (this.done) return;\n    this.done = true;\n    while (this.processors.length > 0) this.processors.pop()(err || true);\n    while (this.processing.length > 0) err ? this.processing.pop()(err) : this.processing.pop()(null, null);\n    while (this.queued.length > 0) err ? this.queued.pop()(err) : this.queued.pop()(null, null);\n    while (this.stack.length > 0) this.stack.pop();\n  }\n\n  destroy(err?: Error) {\n    if (this.destroyed) throw new Error('Already destroyed');\n    this.destroyed = true;\n    this.end(err);\n  }\n}\n\nif (typeof Symbol !== 'undefined' && Symbol.asyncIterator) {\n  StackBaseIterator.prototype[Symbol.asyncIterator] = function asyncIterator() {\n    const self = this;\n    return {\n      next: function next() {\n        return self.next().then(function nextCallback(value) {\n          return Promise.resolve({ value: value, done: value === null });\n        });\n      },\n      destroy: function destroy() {\n        self.destroy();\n        return Promise.resolve();\n      },\n    };\n  };\n}\n"],"names":["once","LinkedList","createProcesor","drainStack","processOrQueue","default","StackBaseIterator","isDone","done","push","fn","console","log","stack","next","value","callback","Promise","resolve","reject","err","result","forEach","options","Error","processorOptions","each","callbacks","concurrency","limit","Infinity","error","defaultError","total","counter","stop","queued","length","processor","bind","destroyed","processors","removeValue","end","pop","processing","destroy","entries","Symbol","asyncIterator","prototype","self","then","nextCallback"],"mappings":"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"}
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/iterators/stack-base-iterator/src/index.ts"],"sourcesContent":["import once from 'call-once-fn';\nimport LinkedList from './LinkedList.js';\n\nimport createProcesor from './createProcessor.js';\nimport drainStack from './drainStack.js';\nimport processOrQueue from './processOrQueue.js';\n\nimport type { AbstractIterator, EachDoneCallback, EachFunction, ForEachOptions, ProcessCallback, Processor, ProcessorOptions, StackFunction, StackOptions } from './types.js';\n\nexport type * from './types.js';\nexport { default as LinkedList } from './LinkedList.js';\nexport default class StackBaseIterator<T> implements AsyncIterator<T> {\n  protected done: boolean;\n  protected stack: LinkedList<StackFunction<T>>;\n  protected processors: LinkedList<Processor>;\n  protected queued: LinkedList<ProcessCallback<T>>;\n  protected processing: LinkedList<ProcessCallback<T>>;\n\n  protected options: StackOptions;\n  protected entries: LinkedList<T>;\n  protected destroyed: boolean;\n\n  constructor(options: StackOptions = {}) {\n    this.options = { ...options };\n    this.options.error =\n      options.error ||\n      function defaultError(err) {\n        return !!err; // fail on errors\n      };\n\n    this.done = false;\n    this.stack = new LinkedList<StackFunction<T>>();\n    this.processors = new LinkedList<Processor>();\n    this.queued = new LinkedList<ProcessCallback<T>>();\n    this.processing = new LinkedList<ProcessCallback<T>>();\n    this.entries = new LinkedList<T>();\n  }\n\n  isDone() {\n    return this.done;\n  }\n\n  push(fn: StackFunction<T>) {\n    if (this.done) return console.log('Attempting to push on a done iterator');\n    this.stack.push(fn);\n    drainStack<T>(this as unknown as AbstractIterator<T>);\n  }\n\n  next(...[value]: [] | [unknown]): Promise<IteratorResult<T, unknown>> {\n    const callback = value as ProcessCallback<T>;\n    if (typeof callback === 'function') {\n      processOrQueue(this as unknown as AbstractIterator<T>, once(callback) as ProcessCallback<T>);\n      return;\n    }\n\n    return new Promise((resolve, reject) => {\n      this.next((err, result) => (err ? reject(err) : resolve(result)));\n    });\n  }\n\n  forEach(fn: EachFunction<T>, options?: ForEachOptions | ProcessCallback<T>, callback?: EachDoneCallback): undefined | Promise<boolean> {\n    if (typeof fn !== 'function') throw new Error('Missing each function');\n    if (typeof options === 'function') {\n      callback = options as EachDoneCallback;\n      options = {};\n    }\n\n    if (typeof callback === 'function') {\n      if (this.done) {\n        callback(null, true);\n        return;\n      }\n      options = options || {};\n      const processorOptions: ProcessorOptions<T> = {\n        each: fn,\n        callbacks: options.callbacks || false,\n        concurrency: options.concurrency || 1,\n        limit: options.limit || Infinity,\n        error:\n          options.error ||\n          function defaultError() {\n            return true; // default is exit on error\n          },\n        total: 0,\n        counter: 0,\n        stop: () => {\n          return this.done || this.queued.length >= this.stack.length;\n        },\n      };\n\n      let processor = createProcesor<T>(this.next.bind(this), processorOptions, (err) => {\n        if (!this.destroyed) this.processors.removeValue(processor);\n        processor = null;\n        options = null;\n        const done = !this.stack.length;\n        if ((err || done) && !this.done) this.end(err);\n        return callback(err, this.done || done);\n      });\n      this.processors.push(processor);\n      processor();\n      return;\n    }\n\n    return new Promise((resolve, reject) =>\n      this.forEach(fn, options, (err?: Error, done?: boolean) => {\n        err ? reject(err) : resolve(done);\n      })\n    );\n  }\n\n  end(err?: Error) {\n    if (this.done) return;\n    this.done = true;\n    while (this.processors.length > 0) this.processors.pop()(err || true);\n    while (this.processing.length > 0) err ? this.processing.pop()(err) : this.processing.pop()(null, null);\n    while (this.queued.length > 0) err ? this.queued.pop()(err) : this.queued.pop()(null, null);\n    while (this.stack.length > 0) this.stack.pop();\n  }\n\n  destroy(err?: Error) {\n    if (this.destroyed) throw new Error('Already destroyed');\n    this.destroyed = true;\n    this.end(err);\n  }\n}\n\nif (typeof Symbol !== 'undefined' && Symbol.asyncIterator) {\n  StackBaseIterator.prototype[Symbol.asyncIterator] = function asyncIterator() {\n    const self = this;\n    return {\n      next: function next() {\n        return self.next().then(function nextCallback(value) {\n          return Promise.resolve({ value: value, done: value === null });\n        });\n      },\n      destroy: function destroy() {\n        self.destroy();\n        return Promise.resolve();\n      },\n    };\n  };\n}\n"],"names":["once","LinkedList","createProcesor","drainStack","processOrQueue","default","StackBaseIterator","isDone","done","push","fn","console","log","stack","next","value","callback","Promise","resolve","reject","err","result","forEach","options","Error","processorOptions","each","callbacks","concurrency","limit","Infinity","error","defaultError","total","counter","stop","queued","length","processor","bind","destroyed","processors","removeValue","end","pop","processing","destroy","entries","Symbol","asyncIterator","prototype","self","then","nextCallback"],"mappings":"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"}

dist/esm/processOrQueue.d.ts

@@ -1,2 +0,2 @@
-import type { AbstractIterator, EachCallback } from './types.js';
-export default function processOrQueue<T>(iterator: AbstractIterator<T>, callback: EachCallback): undefined;
+import type { AbstractIterator, ProcessCallback } from './types.js';
+export default function processOrQueue<T>(iterator: AbstractIterator<T>, callback: ProcessCallback<T>): undefined;

dist/esm/processOrQueue.js.map

@@ -1,1 +0,1 @@
-{"version":3,"sources":["/Users/kevin/Dev/OpenSource/iterators/stack-base-iterator/src/processOrQueue.ts"],"sourcesContent":["import compat from 'async-compat';\n\nimport asap from 'asap';\n\nimport type { AbstractIterator, EachCallback } from './types.js';\n\nexport default function processOrQueue<T>(iterator: AbstractIterator<T>, callback: EachCallback): undefined {\n  if (iterator.done) {\n    callback(null, null);\n    return;\n  }\n\n  // nothing to process so queue\n  if (!iterator.stack.length) {\n    iterator.queued.unshift(callback);\n    return;\n  }\n\n  // process next\n  const next = iterator.stack.pop();\n  iterator.processing.push(callback);\n  next(iterator, (err?: Error, result?: T) => {\n    // break call stack\n    asap(() => {\n      // done is based on stack being empty and not error state as the user may choose to skip the error\n      iterator.processing.removeValue(callback);\n      if (iterator.done) return callback(null, null); // early exit\n      if (err && compat.defaultValue(iterator.options.error(err), true)) err = null; // skip error\n\n      const done = iterator.stack.length <= 0 && iterator.processing.length <= 0;\n      !done && !err && !result ? processOrQueue<T>(iterator, callback) : callback(err, result || null);\n      if (done && !iterator.done) iterator.end(); // end\n    });\n  });\n}\n"],"names":["compat","asap","processOrQueue","iterator","callback","done","stack","length","queued","unshift","next","pop","processing","push","err","result","removeValue","defaultValue","options","error","end"],"mappings":"AAAA,OAAOA,YAAY,eAAe;AAElC,OAAOC,UAAU,OAAO;AAIxB,eAAe,SAASC,eAAkBC,QAA6B,EAAEC,QAAsB;IAC7F,IAAID,SAASE,IAAI,EAAE;QACjBD,SAAS,MAAM;QACf;IACF;IAEA,8BAA8B;IAC9B,IAAI,CAACD,SAASG,KAAK,CAACC,MAAM,EAAE;QAC1BJ,SAASK,MAAM,CAACC,OAAO,CAACL;QACxB;IACF;IAEA,eAAe;IACf,MAAMM,OAAOP,SAASG,KAAK,CAACK,GAAG;IAC/BR,SAASS,UAAU,CAACC,IAAI,CAACT;IACzBM,KAAKP,UAAU,CAACW,KAAaC;QAC3B,mBAAmB;QACnBd,KAAK;YACH,kGAAkG;YAClGE,SAASS,UAAU,CAACI,WAAW,CAACZ;YAChC,IAAID,SAASE,IAAI,EAAE,OAAOD,SAAS,MAAM,OAAO,aAAa;YAC7D,IAAIU,OAAOd,OAAOiB,YAAY,CAACd,SAASe,OAAO,CAACC,KAAK,CAACL,MAAM,OAAOA,MAAM,MAAM,aAAa;YAE5F,MAAMT,OAAOF,SAASG,KAAK,CAACC,MAAM,IAAI,KAAKJ,SAASS,UAAU,CAACL,MAAM,IAAI;YACzE,CAACF,QAAQ,CAACS,OAAO,CAACC,SAASb,eAAkBC,UAAUC,YAAYA,SAASU,KAAKC,UAAU;YAC3F,IAAIV,QAAQ,CAACF,SAASE,IAAI,EAAEF,SAASiB,GAAG,IAAI,MAAM;QACpD;IACF;AACF"}
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/iterators/stack-base-iterator/src/processOrQueue.ts"],"sourcesContent":["import compat from 'async-compat';\n\nimport asap from 'asap';\n\nimport type { AbstractIterator, ProcessCallback } from './types.js';\n\nexport default function processOrQueue<T>(iterator: AbstractIterator<T>, callback: ProcessCallback<T>): undefined {\n  if (iterator.done) {\n    callback(null, null);\n    return;\n  }\n\n  // nothing to process so queue\n  if (!iterator.stack.length) {\n    iterator.queued.unshift(callback);\n    return;\n  }\n\n  // process next\n  const next = iterator.stack.pop();\n  iterator.processing.push(callback);\n  next(iterator, (err?: Error, result?: T): undefined => {\n    // break call stack\n    asap(() => {\n      // done is based on stack being empty and not error state as the user may choose to skip the error\n      iterator.processing.removeValue(callback);\n      if (iterator.done) return callback(null, null); // early exit\n      if (err && compat.defaultValue(iterator.options.error(err), true)) err = null; // skip error\n\n      const done = iterator.stack.length <= 0 && iterator.processing.length <= 0;\n      !done && !err && !result ? processOrQueue<T>(iterator, callback) : callback(err, result || null);\n      if (done && !iterator.done) iterator.end(); // end\n    });\n  });\n}\n"],"names":["compat","asap","processOrQueue","iterator","callback","done","stack","length","queued","unshift","next","pop","processing","push","err","result","removeValue","defaultValue","options","error","end"],"mappings":"AAAA,OAAOA,YAAY,eAAe;AAElC,OAAOC,UAAU,OAAO;AAIxB,eAAe,SAASC,eAAkBC,QAA6B,EAAEC,QAA4B;IACnG,IAAID,SAASE,IAAI,EAAE;QACjBD,SAAS,MAAM;QACf;IACF;IAEA,8BAA8B;IAC9B,IAAI,CAACD,SAASG,KAAK,CAACC,MAAM,EAAE;QAC1BJ,SAASK,MAAM,CAACC,OAAO,CAACL;QACxB;IACF;IAEA,eAAe;IACf,MAAMM,OAAOP,SAASG,KAAK,CAACK,GAAG;IAC/BR,SAASS,UAAU,CAACC,IAAI,CAACT;IACzBM,KAAKP,UAAU,CAACW,KAAaC;QAC3B,mBAAmB;QACnBd,KAAK;YACH,kGAAkG;YAClGE,SAASS,UAAU,CAACI,WAAW,CAACZ;YAChC,IAAID,SAASE,IAAI,EAAE,OAAOD,SAAS,MAAM,OAAO,aAAa;YAC7D,IAAIU,OAAOd,OAAOiB,YAAY,CAACd,SAASe,OAAO,CAACC,KAAK,CAACL,MAAM,OAAOA,MAAM,MAAM,aAAa;YAE5F,MAAMT,OAAOF,SAASG,KAAK,CAACC,MAAM,IAAI,KAAKJ,SAASS,UAAU,CAACL,MAAM,IAAI;YACzE,CAACF,QAAQ,CAACS,OAAO,CAACC,SAASb,eAAkBC,UAAUC,YAAYA,SAASU,KAAKC,UAAU;YAC3F,IAAIV,QAAQ,CAACF,SAASE,IAAI,EAAEF,SAASiB,GAAG,IAAI,MAAM;QACpD;IACF;AACF"}

dist/esm/types.d.ts

 import type LinkedList from './LinkedList.js';
-export type ProcessCallback = (error?: Error, done?: boolean) => void;
-export type Processor = (doneOrError?: Error | boolean) => void;
-export type EachCallback = (error?: Error, value?: unknown) => void;
-export type EachFunctionCallback<T> = (value: T, callback: EachCallback) => undefined;
-export type EachFunctionPromise<T> = (value: T) => Promise<unknown>;
-export type EachFunction<T> = EachFunctionCallback<T> | EachFunctionPromise<T>;
-export type Next = (value: EachCallback) => void;
+export type ProcessCallback<T> = (error?: Error, value?: T | null) => undefined;
+export type Processor = (doneOrError?: Error | boolean) => undefined;
+export type EachDoneCallback = (error?: Error, value?: boolean) => undefined;
+export type EachCallback<T> = (value: T, callback: EachDoneCallback) => undefined;
+export type EachPromise<T> = (value: T) => Promise<boolean>;
+export type EachFunction<T> = EachCallback<T> | EachPromise<T>;
+export type ValueCallback<T> = (error?: Error, value?: T) => boolean;
+export type Next<T> = (callback: ProcessCallback<T>) => undefined;
 export interface StackOptions {
@@ -26,3 +27,3 @@ error?: (err: NodeJS.ErrnoException) => boolean;
 }
-export type StackFunction<T> = (iterator: AbstractIterator<T>, callback: EachCallback) => void;
+export type StackFunction<T> = (iterator: AbstractIterator<T>, callback: ValueCallback<T>) => void;
 export interface AbstractIterator<T> {
@@ -32,6 +33,6 @@ done: boolean;
     processors: LinkedList<Processor>;
-    queued: LinkedList<ProcessCallback>;
-    processing: LinkedList<ProcessCallback>;
+    queued: LinkedList<ProcessCallback<T>>;
+    processing: LinkedList<ProcessCallback<T>>;
     options: StackOptions;
     end: () => undefined;
 }

dist/esm/types.js.map

@@ -1,1 +0,1 @@
-{"version":3,"sources":["/Users/kevin/Dev/OpenSource/iterators/stack-base-iterator/src/types.ts"],"sourcesContent":["import type LinkedList from './LinkedList.js';\n\nexport type ProcessCallback = (error?: Error, done?: boolean) => void;\nexport type Processor = (doneOrError?: Error | boolean) => void;\n\nexport type EachCallback = (error?: Error, value?: unknown) => void;\nexport type EachFunctionCallback<T> = (value: T, callback: EachCallback) => undefined;\nexport type EachFunctionPromise<T> = (value: T) => Promise<unknown>;\nexport type EachFunction<T> = EachFunctionCallback<T> | EachFunctionPromise<T>;\n\nexport type Next = (value: EachCallback) => void;\n\nexport interface StackOptions {\n  error?: (err: NodeJS.ErrnoException) => boolean;\n}\n\nexport interface ForEachOptions {\n  error?: (err: NodeJS.ErrnoException) => boolean;\n  callbacks?: boolean;\n  concurrency?: number;\n  limit?: number;\n}\n\nexport interface ProcessorOptions<T> extends ForEachOptions {\n  each: EachFunction<T>;\n  counter: number;\n  total: number;\n  stop: (count?: number) => boolean;\n  done?: boolean;\n  err?: Error;\n}\n\nexport type StackFunction<T> = (iterator: AbstractIterator<T>, callback: EachCallback) => void;\n\nexport interface AbstractIterator<T> {\n  done: boolean;\n  stack: LinkedList<StackFunction<T>>;\n  processors: LinkedList<Processor>;\n  queued: LinkedList<ProcessCallback>;\n  processing: LinkedList<ProcessCallback>;\n  options: StackOptions;\n  end: () => undefined;\n}\n"],"names":[],"mappings":"AAkCA,WAQC"}
+{"version":3,"sources":["/Users/kevin/Dev/OpenSource/iterators/stack-base-iterator/src/types.ts"],"sourcesContent":["import type LinkedList from './LinkedList.js';\n\nexport type ProcessCallback<T> = (error?: Error, value?: T | null) => undefined;\nexport type Processor = (doneOrError?: Error | boolean) => undefined;\n\nexport type EachDoneCallback = (error?: Error, value?: boolean) => undefined;\nexport type EachCallback<T> = (value: T, callback: EachDoneCallback) => undefined;\nexport type EachPromise<T> = (value: T) => Promise<boolean>;\nexport type EachFunction<T> = EachCallback<T> | EachPromise<T>;\n\nexport type ValueCallback<T> = (error?: Error, value?: T) => boolean;\nexport type Next<T> = (callback: ProcessCallback<T>) => undefined;\n\nexport interface StackOptions {\n  error?: (err: NodeJS.ErrnoException) => boolean;\n}\n\nexport interface ForEachOptions {\n  error?: (err: NodeJS.ErrnoException) => boolean;\n  callbacks?: boolean;\n  concurrency?: number;\n  limit?: number;\n}\n\nexport interface ProcessorOptions<T> extends ForEachOptions {\n  each: EachFunction<T>;\n  counter: number;\n  total: number;\n  stop: (count?: number) => boolean;\n  done?: boolean;\n  err?: Error;\n}\n\nexport type StackFunction<T> = (iterator: AbstractIterator<T>, callback: ValueCallback<T>) => void;\n\nexport interface AbstractIterator<T> {\n  done: boolean;\n  stack: LinkedList<StackFunction<T>>;\n  processors: LinkedList<Processor>;\n  queued: LinkedList<ProcessCallback<T>>;\n  processing: LinkedList<ProcessCallback<T>>;\n  options: StackOptions;\n  end: () => undefined;\n}\n"],"names":[],"mappings":"AAmCA,WAQC"}

package.json

 {
   "name": "stack-base-iterator",
-  "version": "1.2.20",
+  "version": "1.2.21",
   "description": "Base iterator for values retrieved using a stack of async functions returning values",
@@ -5,0 +5,0 @@ "keywords": [

No alert changes

Improved metrics

Total package byte prevSize

78347

1.37%

Lines of code

853

1.67%

No dependency changes