Initial commit: New MoreminiMore website with fresh design

node_modules/promise-limit/index.d.ts

@@ -0,0 +1,45 @@
+export = limitFactory
+
+declare namespace limitFactory {}
+
+/**
+ * Returns a function that can be used to wrap promise returning functions,
+ * limiting them to concurrency outstanding calls.
+ * @param concurrency the concurrency, i.e. 1 will limit calls to one at a
+ * time, effectively in sequence or serial. 2 will allow two at a time, etc.
+ * 0 or undefined specify no limit, and all calls will be run in parallel.
+ */
+declare function limitFactory<T>(concurrency?: number): limit<T>
+
+declare type limit<T> = limitFunc<T> & limitInterface<T>
+
+declare interface limitInterface<T> {
+  /**
+   * Maps an array of items using mapper, but limiting the number of concurrent
+   * calls to mapper with the concurrency of limit. If at least one call to
+   * mapper returns a rejected promise, the result of map is a the same rejected
+   * promise, and no further calls to mapper are made.
+   * @param items any items
+   * @param mapper iterator
+   */
+  map<U>(items: ReadonlyArray<T>, mapper: (value: T) => Promise<U>): Promise<U[]>
+
+  /**
+   * Returns the queue length, the number of jobs that are waiting to be started.
+   * You could use this to throttle incoming jobs, so the queue doesn't
+   * overwhealm the available memory - for e.g. pause() a stream.
+  */
+  queue: number
+}
+
+/**
+ * A function that limits calls to fn, based on concurrency above. Returns a
+ * promise that resolves or rejects the same value or error as fn. All functions
+ * are executed in the same order in which they were passed to limit. fn must
+ * return a promise.
+ * @param fn a function that is called with no arguments and returns a promise.
+ * You can pass arguments to your function by putting it inside another function,
+ * i.e. `() -> myfunc(a, b, c)`.
+*/
+declare type limitFunc<T> = (fn: () => Promise<T>) => Promise<T>
+