From 7a52ddeba2a68388b544f529d2d92104420f77b0 Mon Sep 17 00:00:00 2001 From: Shipwreckt Date: Fri, 31 Oct 2025 20:02:14 +0000 Subject: Changed from static to 11ty! --- node_modules/a-sync-waterfall/LICENSE | 21 +++++++ node_modules/a-sync-waterfall/README.md | 95 ++++++++++++++++++++++++++++++ node_modules/a-sync-waterfall/index.js | 83 ++++++++++++++++++++++++++ node_modules/a-sync-waterfall/package.json | 21 +++++++ node_modules/a-sync-waterfall/test.js | 77 ++++++++++++++++++++++++ 5 files changed, 297 insertions(+) create mode 100644 node_modules/a-sync-waterfall/LICENSE create mode 100644 node_modules/a-sync-waterfall/README.md create mode 100644 node_modules/a-sync-waterfall/index.js create mode 100644 node_modules/a-sync-waterfall/package.json create mode 100644 node_modules/a-sync-waterfall/test.js (limited to 'node_modules/a-sync-waterfall') diff --git a/node_modules/a-sync-waterfall/LICENSE b/node_modules/a-sync-waterfall/LICENSE new file mode 100644 index 0000000..e684cdb --- /dev/null +++ b/node_modules/a-sync-waterfall/LICENSE @@ -0,0 +1,21 @@ +The MIT License (MIT) + +Copyright (c) 2013 Elan Shanker + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the “Software”), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in +all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +THE SOFTWARE. diff --git a/node_modules/a-sync-waterfall/README.md b/node_modules/a-sync-waterfall/README.md new file mode 100644 index 0000000..e3d5afe --- /dev/null +++ b/node_modules/a-sync-waterfall/README.md @@ -0,0 +1,95 @@ +# a-sync-waterfall + +Simple, isolated sync/async waterfall module for JavaScript. + +Runs an array of functions in series, each passing their results to the next in +the array. However, if any of the functions pass an error to the callback, the +next function is not executed and the main callback is immediately called with +the error. + +For browsers and node.js. + +## Installation +* Just include a-sync-waterfall before your scripts. +* `npm install a-sync-waterfall` if you’re using node.js. + + +## Usage + +* `waterfall(tasks, optionalCallback, forceAsync);` +* **tasks** - An array of functions to run, each function is passed a +`callback(err, result1, result2, ...)` it must call on completion. The first +argument is an error (which can be null) and any further arguments will be +passed as arguments in order to the next task. +* **optionalCallback** - An optional callback to run once all the functions have +completed. This will be passed the results of the last task's callback. +* **forceAsync** An optional flag that force tasks run asynchronously even if they are sync. + +##### Node.js: + +```javascript +var waterfall = require('a-sync-waterfall'); +waterfall(tasks, callback); +``` + +##### Browser: + +```javascript +var waterfall = require('a-sync-waterfall'); +waterfall(tasks, callback); + +// Default: +window.waterfall(tasks, callback); +``` + +##### Tasks as Array of Functions + +```javascript +waterfall([ + function(callback){ + callback(null, 'one', 'two'); + }, + function(arg1, arg2, callback){ + callback(null, 'three'); + }, + function(arg1, callback){ + // arg1 now equals 'three' + callback(null, 'done'); + } +], function (err, result) { + // result now equals 'done' +}); +``` + +##### Derive Tasks from an Array.map + +```javascript +/* basic - no arguments */ +waterfall(myArray.map(function (arrayItem) { + return function (nextCallback) { + // same execution for each item, call the next one when done + doAsyncThingsWith(arrayItem, nextCallback); +}})); + +/* with arguments, initializer function, and final callback */ +waterfall([function initializer (firstMapFunction) { + firstMapFunction(null, initialValue); + }].concat(myArray.map(function (arrayItem) { + return function (lastItemResult, nextCallback) { + // same execution for each item in the array + var itemResult = doThingsWith(arrayItem, lastItemResult); + // results carried along from each to the next + nextCallback(null, itemResult); +}})), function (err, finalResult) { + // final callback +}); +``` + +## Acknowledgements +Hat tip to [Caolan McMahon](https://github.com/caolan) and +[Paul Miller](https://github.com/paulmillr), whose prior contributions this is +based upon. +Also [Elan Shanker](https://github.com/es128) from which this rep is forked + +## License +[MIT](https://raw.github.com/hydiak/a-sync-waterfall/master/LICENSE) diff --git a/node_modules/a-sync-waterfall/index.js b/node_modules/a-sync-waterfall/index.js new file mode 100644 index 0000000..5671213 --- /dev/null +++ b/node_modules/a-sync-waterfall/index.js @@ -0,0 +1,83 @@ +// MIT license (by Elan Shanker). +(function(globals) { + 'use strict'; + + var executeSync = function(){ + var args = Array.prototype.slice.call(arguments); + if (typeof args[0] === 'function'){ + args[0].apply(null, args.splice(1)); + } + }; + + var executeAsync = function(fn){ + if (typeof setImmediate === 'function') { + setImmediate(fn); + } else if (typeof process !== 'undefined' && process.nextTick) { + process.nextTick(fn); + } else { + setTimeout(fn, 0); + } + }; + + var makeIterator = function (tasks) { + var makeCallback = function (index) { + var fn = function () { + if (tasks.length) { + tasks[index].apply(null, arguments); + } + return fn.next(); + }; + fn.next = function () { + return (index < tasks.length - 1) ? makeCallback(index + 1): null; + }; + return fn; + }; + return makeCallback(0); + }; + + var _isArray = Array.isArray || function(maybeArray){ + return Object.prototype.toString.call(maybeArray) === '[object Array]'; + }; + + var waterfall = function (tasks, callback, forceAsync) { + var nextTick = forceAsync ? executeAsync : executeSync; + callback = callback || function () {}; + if (!_isArray(tasks)) { + var err = new Error('First argument to waterfall must be an array of functions'); + return callback(err); + } + if (!tasks.length) { + return callback(); + } + var wrapIterator = function (iterator) { + return function (err) { + if (err) { + callback.apply(null, arguments); + callback = function () {}; + } else { + var args = Array.prototype.slice.call(arguments, 1); + var next = iterator.next(); + if (next) { + args.push(wrapIterator(next)); + } else { + args.push(callback); + } + nextTick(function () { + iterator.apply(null, args); + }); + } + }; + }; + wrapIterator(makeIterator(tasks))(); + }; + + if (typeof define !== 'undefined' && define.amd) { + define([], function () { + return waterfall; + }); // RequireJS + } else if (typeof module !== 'undefined' && module.exports) { + module.exports = waterfall; // CommonJS + } else { + globals.waterfall = waterfall; //