aix 0.0.14 → 0.1.0-alpha.1

package/src/deferredIterable.ts

@@ -1,111 +0,0 @@
-import { Deferred } from "./deferred";
-
-/**
- * The async iterator equivalent of a deferred
- */
-export class DeferredIterable<T> {
-  doneValue = {
-    done: true,
-    value: {} as T
-  };
-
-  queue: IteratorResult<T>[] = [];
-  deferreds: Deferred<IteratorResult<T>>[] = [];
-  iterator: AsyncIterableIterator<T>;
-  done: boolean = false;
-  noMoreResults: boolean = false;
-  backPressureDeferred = new Deferred<void>();
-
-  finallyCallbacks: (() => void)[] = [];
-
-  constructor() {
-    const self = this;
-
-    this.iterator = {
-      throw(e?: any) {
-        self.done = true;
-        self.finallyCallbacks.map(cb => cb());
-        // fail any waiting deferreds
-        for (const deferred of self.deferreds) {
-          deferred.reject(e);
-        }
-        return Promise.reject(e);
-      },
-      return(value?: any) {
-        self.done = true;
-        self.finallyCallbacks.map(cb => cb());
-        // fail any waiting deferreds
-        for (const deferred of self.deferreds) {
-          deferred.resolve({
-            done: true,
-            value: {} as T
-          });
-        }
-        return Promise.resolve(self.doneValue);
-      },
-      next(value?: any) {
-        const queuedItem = self.queue.shift();
-        if (self.queue.length === 0) {
-          self.backPressureDeferred.resolve();
-          self.backPressureDeferred = new Deferred<void>();
-        }
-        if (queuedItem !== undefined) {
-          return Promise.resolve(queuedItem);
-        } else {
-          if (self.noMoreResults && !self.done) {
-            self.done = true;
-            self.finallyCallbacks.map(cb => cb());
-          }
-          if (self.done) {
-            return Promise.resolve({
-              done: true,
-              value: {} as T
-            });
-          }
-          const deferred = new Deferred<IteratorResult<T>>();
-          self.deferreds.push(deferred);
-          return deferred.promise;
-        }
-      },
-      [Symbol.asyncIterator]() {
-        return this;
-      }
-    };
-  }
-
-  finally(callback: () => void) {
-    this.finallyCallbacks.push(callback);
-  }
-
-  close() {
-    return this.callback({ done: true, value: {} as T });
-  }
-
-  value(value: T) {
-    return this.callback({ done: false, value });
-  }
-
-  callback(result: IteratorResult<T>) {
-    if (!(this && this instanceof DeferredIterable)) {
-      const errorMessage =
-        "This must be a DeferredIterable. Have you bound this?";
-      console.log(errorMessage);
-      throw new Error(errorMessage);
-    }
-    if (result.done) {
-      for (const deferred of this.deferreds) {
-        deferred.resolve(result);
-      }
-      this.noMoreResults = true;
-      return Promise.resolve();
-    }
-    const deferred = this.deferreds.pop();
-    if (deferred !== undefined) {
-      deferred.resolve(result);
-      return Promise.resolve();
-    } else {
-      this.queue.push(result);
-      return this.backPressureDeferred.promise;
-    }
-  }
-}

package/src/filter.ts

@@ -1,16 +0,0 @@
-/**
- * Filters items from an iterable
- *
- * @param source the source iterable to filter
- * @param predicate the predicate to apply to filter items
- */
-export function filter<T>(predicate: (t: T) => boolean) {
-  return async function* inner(source: AsyncIterable<T>) {
-    for await (const item of source) {
-      if (predicate(item)) {
-        yield item;
-      }
-    }
-  };
-}
-

package/src/flatMap.ts

@@ -1,9 +0,0 @@
-export function flatMap<TFrom, TTo>(mapper: (t: TFrom) => AsyncIterable<TTo>) {
-  return async function* inner(source: AsyncIterable<TFrom>) {
-    for await (const item of source) {
-      for await (const nestedItem of mapper(item)) {
-        yield nestedItem;
-      }
-    }
-  };
-}

package/src/fromEvent.ts

@@ -1,16 +0,0 @@
-import DeferredIterable from "./deferredIterable";
-
-export interface EventSource<T> {
-  addEventListener: (type: string, callback: (event: T) => void) => void;
-  removeEventListener: (type: string, callback: any) => void;
-}
-
-export function fromEvent<T>(source: EventSource<T>, type: string) {
-  const deferredIterable = new DeferredIterable<T>();
-  const callback = (event: T) => {
-    deferredIterable.value(event);
-  };
-  source.addEventListener(type, callback);
-  deferredIterable.finally(() => source.removeEventListener(type, callback));
-  return deferredIterable.iterator;
-}

package/src/insert.ts

@@ -1,13 +0,0 @@
-/**
- * Inserts values at the start of the iterable
- */
-export function insert<T>(...values: T[]) {
-  return async function* inner(source: AsyncIterable<T>) {
-    for (const value of values) {
-      yield value;
-    }
-    for await (const item of source) {
-      yield item;
-    }
-  };
-}

package/src/interval.ts

@@ -1,20 +0,0 @@
-import DeferredIterable from "./deferredIterable";
-
-/**
- * Emit numbers in sequence
- */
-export function interval<T>(
-  period: number,
-  timeout?: ((callback: () => void, delay: number) => void)
-) {
-  const deferredIterable = new DeferredIterable<number>();
-  let counter = 0;
-  async function inner() {
-    if (!deferredIterable.done) {
-      await deferredIterable.value(counter++);
-      (timeout || setTimeout)(inner, period);
-    }
-  }
-  inner();
-  return deferredIterable.iterator;
-}

package/src/iterableToArray.ts

@@ -1,7 +0,0 @@
-export async function iterableToArray<T>(source: AsyncIterable<T>) {
-  const result = [];
-  for await (const item of source) {
-    result.push(item);
-  }
-  return result;
-}

package/src/iteratorToIterable.ts

@@ -1,12 +0,0 @@
-/**
- * Helper function to turn an iterator into an iterable
- *
- * @param iterator An iteratable
- */
-export async function* iteratorToIterable<T>(iterator: AsyncIterator<T>) {
-  while (true) {
-    const next = await iterator.next();
-    if (next.done) return;
-    yield next.value;
-  }
-}

package/src/lookahead.ts

@@ -1,27 +0,0 @@
-import { iteratorToIterable } from "./iteratorToIterable";
-import insert from "./insert";
-
-/**
- * Lookahead into the async iteratable
- *
- * @param source The source iterable to look into
- * @param howFar How far to look ahead
- */
-export function lookahead<T>(howFar: number) {
-  return async function inner(
-    source: AsyncIterable<T>
-  ): Promise<{ values: Array<T>; iterable: AsyncIterable<T> }> {
-    const iterator = source[Symbol.asyncIterator]();
-    const values: Array<T> = [];
-    for (let i = 0; i < howFar; i++) {
-      const next = await iterator.next();
-      if (next.done) break;
-      values.push(next.value);
-    }
-    return {
-      values,
-      iterable: insert(...values)(iteratorToIterable(iterator))
-    };
-  };
-}
-

package/src/map.ts

@@ -1,11 +0,0 @@
-/**
- * Concatenates to iterables
- */
-export function map<TFrom, TTo>(mapper: (t: TFrom, index: number) => TTo) {
-  return async function* inner(source: AsyncIterable<TFrom>) {
-    let index = 0;
-    for await (const item of source) {
-      yield mapper(item, index++);
-    }
-  };
-}

package/src/merge.ts

@@ -1,16 +0,0 @@
-
-/**
- * Merges iterables
- *
- * @param sources the iterables to merge
- */
-export function merge<T>(...sources: AsyncIterable<T>[]) {
-  const deferredIterable = new DeferredIterable<T>();
-  sources.map(source => {
-    return toCallbacks(
-      source,
-      deferredIterable.callback.bind(deferredIterable)
-    );
-  });
-  return deferredIterable.iterator;
-}

package/src/of.ts

@@ -1,4 +0,0 @@
-import { restToIterable } from "./restToIterable";
-
-export const of = restToIterable;
-export default of;

package/src/reduce.ts

@@ -1,12 +0,0 @@
-/**
- * Reduces values
- */
-export function reduce<T, A>(reducer: (accumulator: A, next: T) => A, init: A) {
-  return async function inner(source: AsyncIterable<T>) {
-    let accumulator = init;
-    for await (const next of source) {
-      accumulator = reducer(accumulator, next);
-    }
-    return accumulator;
-  };
-}

package/src/restToIterable.ts

@@ -1,8 +0,0 @@
-/**
- * @param values values to be returned by the async iterable
- */
-export async function* restToIterable<T>(...values: Array<T>) {
-  for (let item of values) {
-    yield item;
-  }
-}

package/src/spanAll.ts

@@ -1,26 +0,0 @@
-import { DeferredIterable, toCallbacks } from ".";
-
-export function spanAll<T>(predicate: (t: T) => boolean) {
-  return function inner(source: AsyncIterable<T>) {
-    const spanDeferredIterable = new DeferredIterable<AsyncIterable<T>>();
-    let currentDeferredIterable = new DeferredIterable<T>();
-    spanDeferredIterable.value(currentDeferredIterable.iterator);
-    toCallbacks(source, result => {
-      if (result.done) {
-        currentDeferredIterable.close();
-        spanDeferredIterable.close();
-        return Promise.resolve();
-      }
-      if (predicate(result.value)) {
-        currentDeferredIterable.close();
-        currentDeferredIterable = new DeferredIterable<T>();
-        spanDeferredIterable.value(currentDeferredIterable.iterator);
-      } else {
-        currentDeferredIterable.value(result.value);
-      }
-      // not handling back pressure at the moment
-      return Promise.resolve();
-    });
-    return spanDeferredIterable.iterator;
-  };
-}

package/src/tap.ts

@@ -1,11 +0,0 @@
-/**
- * Tap an iterable
- */
-export function tap<T>(func: (t: T) => void) {
-  return async function* inner(source: AsyncIterable<T>) {
-    for await (const item of source) {
-      func(item);
-      yield item;
-    }
-  };
-}

package/src/toCallbacks.ts

@@ -1,27 +0,0 @@
-/** Provides a way for callbacks to signal early completion */
-export class StopError extends Error {}
-
-/**
- * Converts an async iterable into a series of callbacks. The function returns
- * a promise that resolves when the stream is done
- *
- * @param source the source iterable
- * @param callback the callback that gets called for each value
- */
-export async function toCallbacks<T>(
-  source: AsyncIterable<T>,
-  callback: (result: IteratorResult<T>) => Promise<void>
-) {
-  const iterator = source[Symbol.asyncIterator]();
-  while (true) {
-    const result = await iterator.next();
-    try {
-      await callback(result);
-    } catch (StopError) {
-      return;
-    }
-    if (result.done) {
-      return;
-    }
-  }
-}

package/src/zip.ts

@@ -1,19 +0,0 @@
-/**
- * Zips two iterables
- */
-export function zip<T>(first: AsyncIterable<T>) {
-  return async function* inner(second: AsyncIterable<T>) {
-    const iterators = [first, second].map(value =>
-      value[Symbol.asyncIterator]()
-    );
-    while (true) {
-      const [firstNext, secondNext] = await Promise.all(
-        iterators.map(iterator => iterator.next())
-      );
-      if (firstNext.done || secondNext.done) {
-        return;
-      }
-      yield [firstNext, secondNext];
-    }
-  };
-}

package/tsconfig.json

@@ -1,63 +0,0 @@
-{
-  "compilerOptions": {
-    /* Basic Options */
-    "target":
-      "es5" /* Specify ECMAScript target version: 'ES3' (default), 'ES5', 'ES2015', 'ES2016', 'ES2017','ES2018' or 'ESNEXT'. */,
-    "module":
-      "commonjs" /* Specify module code generation: 'none', 'commonjs', 'amd', 'system', 'umd', 'es2015', or 'ESNext'. */,
-    "lib": [
-      "esnext",
-      "dom"
-    ] /* Specify library files to be included in the compilation. */,
-    // "allowJs": true,                       /* Allow javascript files to be compiled. */
-    // "checkJs": true,                       /* Report errors in .js files. */
-    // "jsx": "preserve",                     /* Specify JSX code generation: 'preserve', 'react-native', or 'react'. */
-    "declaration": true,                   /* Generates corresponding '.d.ts' file. */
-    // "sourceMap": true,                     /* Generates corresponding '.map' file. */
-    // "outFile": "./",                       /* Concatenate and emit output to single file. */
-    "outDir": "./lib" /* Redirect output structure to the directory. */,
-    "rootDir":
-      "./src" /* Specify the root directory of input files. Use to control the output directory structure with --outDir. */,
-    // "removeComments": true,                /* Do not emit comments to output. */
-    // "noEmit": true,                        /* Do not emit outputs. */
-    // "importHelpers": true,                 /* Import emit helpers from 'tslib'. */
-    // "downlevelIteration": true,            /* Provide full support for iterables in 'for-of', spread, and destructuring when targeting 'ES5' or 'ES3'. */
-    // "isolatedModules": true,               /* Transpile each file as a separate module (similar to 'ts.transpileModule'). */
-
-    /* Strict Type-Checking Options */
-    "strict": true /* Enable all strict type-checking options. */,
-    "noImplicitAny": true /* Raise error on expressions and declarations with an implied 'any' type. */,
-    "strictNullChecks": true /* Enable strict null checks. */,
-    "strictFunctionTypes": true /* Enable strict checking of function types. */,
-    "strictPropertyInitialization": true /* Enable strict checking of property initialization in classes. */,
-    "noImplicitThis": true /* Raise error on 'this' expressions with an implied 'any' type. */,
-    "alwaysStrict": true /* Parse in strict mode and emit "use strict" for each source file. */,
-
-    /* Additional Checks */
-    // "noUnusedLocals": true,                /* Report errors on unused locals. */
-    // "noUnusedParameters": true,            /* Report errors on unused parameters. */
-    // "noImplicitReturns": true,             /* Report error when not all code paths in function return a value. */
-    // "noFallthroughCasesInSwitch": true,    /* Report errors for fallthrough cases in switch statement. */
-
-    /* Module Resolution Options */
-    // "moduleResolution": "node",            /* Specify module resolution strategy: 'node' (Node.js) or 'classic' (TypeScript pre-1.6). */
-    // "baseUrl": "./",                       /* Base directory to resolve non-absolute module names. */
-    // "paths": {},                           /* A series of entries which re-map imports to lookup locations relative to the 'baseUrl'. */
-    // "rootDirs": [],                        /* List of root folders whose combined content represents the structure of the project at runtime. */
-    // "typeRoots": [],                       /* List of folders to include type definitions from. */
-    // "types": [],                           /* Type declaration files to be included in compilation. */
-    // "allowSyntheticDefaultImports": true,  /* Allow default imports from modules with no default export. This does not affect code emit, just typechecking. */
-    "esModuleInterop": true /* Enables emit interoperability between CommonJS and ES Modules via creation of namespace objects for all imports. Implies 'allowSyntheticDefaultImports'. */
-    // "preserveSymlinks": true,              /* Do not resolve the real path of symlinks. */
-
-    /* Source Map Options */
-    // "sourceRoot": "./",                    /* Specify the location where debugger should locate TypeScript files instead of source locations. */
-    // "mapRoot": "./",                       /* Specify the location where debugger should locate map files instead of generated locations. */
-    // "inlineSourceMap": true,               /* Emit a single file with source maps instead of having a separate file. */
-    // "inlineSources": true,                 /* Emit the source alongside the sourcemaps within a single file; requires '--inlineSourceMap' or '--sourceMap' to be set. */
-
-    /* Experimental Options */
-    // "experimentalDecorators": true,        /* Enables experimental support for ES7 decorators. */
-    // "emitDecoratorMetadata": true,         /* Enables experimental support for emitting type metadata for decorators. */
-  }
-}