visaljs 0.0.6 → 0.0.8

package/node/prelude/internal/streams/from.js

@@ -0,0 +1,211 @@
+import * as __buffer from "../../buffer.js";
+import * as __internal_errors from "./errors.js";
+
+const { Buffer } = __buffer;
+
+const {
+  aggregateTwoErrors,
+  codes: {
+    ERR_INVALID_ARG_TYPE,
+    ERR_STREAM_NULL_VALUES,
+  },
+} = __internal_errors;
+
+function from(Readable, iterable, opts) {
+  let iterator;
+  if (typeof iterable === 'string' || iterable instanceof Buffer) {
+    return new Readable({
+      objectMode: true,
+      ...opts,
+      read() {
+        this.push(iterable);
+        this.push(null);
+      },
+    });
+  }
+
+  let isAsync;
+  if (iterable?.[Symbol.asyncIterator]) {
+    isAsync = true;
+    iterator = iterable[Symbol.asyncIterator]();
+  } else if (iterable?.[Symbol.iterator]) {
+    isAsync = false;
+    iterator = iterable[Symbol.iterator]();
+  } else {
+    throw new ERR_INVALID_ARG_TYPE('iterable', ['Iterable'], iterable);
+  }
+
+
+  const readable = new Readable({
+    objectMode: true,
+    highWaterMark: 1,
+    // TODO(ronag): What options should be allowed?
+    ...opts,
+  });
+  const originalDestroy = readable._destroy;
+
+  // Flag to protect against _read
+  // being called before last iteration completion.
+  let reading = false;
+  let isAsyncValues = false;
+
+  readable._read = function() {
+    if (!reading) {
+      reading = true;
+
+      if (isAsync) {
+        nextAsync();
+      } else if (isAsyncValues) {
+        nextSyncWithAsyncValues();
+      } else {
+        nextSyncWithSyncValues();
+      }
+    }
+  };
+
+  readable._destroy = function(error, cb) {
+    originalDestroy.call(this, error, (destroyError) => {
+      const combinedError = destroyError || error;
+      (close(combinedError)).then(// nextTick is here in case cb throws
+        () => process.nextTick(cb, combinedError), (closeError) => process.nextTick(
+          cb,
+          aggregateTwoErrors(combinedError, closeError),
+        ), );
+    });
+  };
+
+  async function close(error) {
+    const hadError = (error !== undefined) && (error !== null);
+    const hasThrow = typeof iterator.throw === 'function';
+    if (hadError && hasThrow) {
+      const { value, done } = await iterator.throw(error);
+      await value;
+      if (done) {
+        return;
+      }
+    }
+    if (typeof iterator.return === 'function') {
+      const { value } = await iterator.return();
+      await value;
+    }
+  }
+
+  // There are a lot of duplication here, it's done on purpose for performance
+  // reasons - avoid await when not needed.
+
+  function nextSyncWithSyncValues() {
+    for (;;) {
+      try {
+        const { value, done } = iterator.next();
+
+        if (done) {
+          readable.push(null);
+          return;
+        }
+
+        if (value &&
+          typeof value.then === 'function') {
+          return changeToAsyncValues(value);
+        }
+
+        if (value === null) {
+          reading = false;
+          throw new ERR_STREAM_NULL_VALUES();
+        }
+
+        if (readable.push(value)) {
+          continue;
+        }
+
+        reading = false;
+      } catch (err) {
+        readable.destroy(err);
+      }
+      break;
+    }
+  }
+
+  async function changeToAsyncValues(value) {
+    isAsyncValues = true;
+
+    try {
+      const res = await value;
+
+      if (res === null) {
+        reading = false;
+        throw new ERR_STREAM_NULL_VALUES();
+      }
+
+      if (readable.push(res)) {
+        nextSyncWithAsyncValues();
+        return;
+      }
+
+      reading = false;
+    } catch (err) {
+      readable.destroy(err);
+    }
+  }
+
+  async function nextSyncWithAsyncValues() {
+    for (;;) {
+      try {
+        const { value, done } = iterator.next();
+
+        if (done) {
+          readable.push(null);
+          return;
+        }
+
+        const res = (value &&
+          typeof value.then === 'function') ?
+          await value :
+          value;
+
+        if (res === null) {
+          reading = false;
+          throw new ERR_STREAM_NULL_VALUES();
+        }
+
+        if (readable.push(res)) {
+          continue;
+        }
+
+        reading = false;
+      } catch (err) {
+        readable.destroy(err);
+      }
+      break;
+    }
+  }
+
+  async function nextAsync() {
+    for (;;) {
+      try {
+        const { value, done } = await iterator.next();
+
+        if (done) {
+          readable.push(null);
+          return;
+        }
+
+        if (value === null) {
+          reading = false;
+          throw new ERR_STREAM_NULL_VALUES();
+        }
+
+        if (readable.push(value)) {
+          continue;
+        }
+
+        reading = false;
+      } catch (err) {
+        readable.destroy(err);
+      }
+      break;
+    }
+  }
+  return readable;
+}
+
+export default from;

package/node/prelude/internal/streams/legacy.js

@@ -0,0 +1,120 @@
+import * as __events from "../../events.js";
+
+const EE = __events.default;
+
+function Stream(opts) {
+  EE.call(this, opts);
+}
+Object.setPrototypeOf(Stream.prototype, EE.prototype);
+Object.setPrototypeOf(Stream, EE);
+
+Stream.prototype.pipe = function(dest, options) {
+  const source = this;
+
+  function ondata(chunk) {
+    if (dest.writable && dest.write(chunk) === false && source.pause) {
+      source.pause();
+    }
+  }
+
+  source.on('data', ondata);
+
+  function ondrain() {
+    if (source.readable && source.resume) {
+      source.resume();
+    }
+  }
+
+  dest.on('drain', ondrain);
+
+  // If the 'end' option is not supplied, dest.end() will be called when
+  // source gets the 'end' or 'close' events.  Only dest.end() once.
+  if (!dest._isStdio && (!options || options.end !== false)) {
+    source.on('end', onend);
+    source.on('close', onclose);
+  }
+
+  let didOnEnd = false;
+  function onend() {
+    if (didOnEnd) return;
+    didOnEnd = true;
+
+    dest.end();
+  }
+
+
+  function onclose() {
+    if (didOnEnd) return;
+    didOnEnd = true;
+
+    if (typeof dest.destroy === 'function') dest.destroy();
+  }
+
+  // Don't leave dangling pipes when there are errors.
+  function onerror(er) {
+    cleanup();
+    // If we removed the last error handler, trigger an unhandled error event.
+    if (this.listenerCount?.('error') === 0) {
+      this.emit('error', er);
+    }
+  }
+
+  prependListener(source, 'error', onerror);
+  prependListener(dest, 'error', onerror);
+
+  // Remove all the event listeners that were added.
+  function cleanup() {
+    source.removeListener('data', ondata);
+    dest.removeListener('drain', ondrain);
+
+    source.removeListener('end', onend);
+    source.removeListener('close', onclose);
+
+    source.removeListener('error', onerror);
+    dest.removeListener('error', onerror);
+
+    source.removeListener('end', cleanup);
+    source.removeListener('close', cleanup);
+
+    dest.removeListener('close', cleanup);
+  }
+
+  source.on('end', cleanup);
+  source.on('close', cleanup);
+
+  dest.on('close', cleanup);
+  dest.emit('pipe', source);
+
+  // Allow for unix-like usage: A.pipe(B).pipe(C)
+  return dest;
+};
+
+Stream.prototype.eventNames = function eventNames() {
+  const names = [];
+  for (const key of Reflect.ownKeys(this._events)) {
+    if (typeof this._events[key] === 'function' || (Array.isArray(this._events[key]) && this._events[key].length > 0)) {
+      names.push(key);
+    }
+  }
+  return names;
+};
+
+function prependListener(emitter, event, fn) {
+  // Sadly this is not cacheable as some libraries bundle their own
+  // event emitter implementation with them.
+  if (typeof emitter.prependListener === 'function')
+    return emitter.prependListener(event, fn);
+
+  // This is a hack to make sure that our error handler is attached before any
+  // userland ones.  NEVER DO THIS. This is here only because this code needs
+  // to continue to work with older versions of Node.js that do not include
+  // the prependListener() method. The goal is to eventually remove this hack.
+  if (!emitter._events || !emitter._events[event])
+    emitter.on(event, fn);
+  else if (Array.isArray(emitter._events[event]))
+    emitter._events[event].unshift(fn);
+  else
+    emitter._events[event] = [fn, emitter._events[event]];
+}
+
+export { Stream, prependListener };

package/node/prelude/internal/streams/operators.js

@@ -0,0 +1,375 @@
+import * as __internal_errors from "./errors.js";
+import * as __internal_validators from "./validators.js";
+import * as __internal_streams_end_of_stream from "./end_of_stream.js";
+
+const {
+  AbortError,
+  codes: {
+    ERR_MISSING_ARGS,
+    ERR_OUT_OF_RANGE,
+  },
+} = __internal_errors;
+const {
+  validateAbortSignal,
+  validateInteger,
+  validateObject,
+  validateFunction,
+} = __internal_validators;
+const { finished } = __internal_streams_end_of_stream;
+
+const kEmpty = Symbol('kEmpty');
+const kEof = Symbol('kEof');
+
+function map(fn, options) {
+  validateFunction(fn, 'fn');
+  if (options != null) {
+    validateObject(options, 'options');
+  }
+  if (options?.signal != null) {
+    validateAbortSignal(options.signal, 'options.signal');
+  }
+
+  let concurrency = 1;
+  if (options?.concurrency != null) {
+    concurrency = Math.floor(options.concurrency);
+  }
+
+  let highWaterMark = concurrency - 1;
+  if (options?.highWaterMark != null) {
+    highWaterMark = Math.floor(options.highWaterMark);
+  }
+
+  validateInteger(concurrency, 'options.concurrency', 1);
+  validateInteger(highWaterMark, 'options.highWaterMark', 0);
+
+  highWaterMark += concurrency;
+
+  return async function* map() {
+    const signal = AbortSignal.any([options?.signal].filter(Boolean));
+    const stream = this;
+    const queue = [];
+    const signalOpt = { signal };
+
+    let next;
+    let resume;
+    let done = false;
+    let cnt = 0;
+
+    function onCatch() {
+      done = true;
+      afterItemProcessed();
+    }
+
+    function afterItemProcessed() {
+      cnt -= 1;
+      maybeResume();
+    }
+
+    function maybeResume() {
+      if (
+        resume &&
+        !done &&
+        cnt < concurrency &&
+        queue.length < highWaterMark
+      ) {
+        resume();
+        resume = null;
+      }
+    }
+
+    async function pump() {
+      try {
+        for await (let val of stream) {
+          if (done) {
+            return;
+          }
+
+          if (signal.aborted) {
+            throw new AbortError();
+          }
+
+          try {
+            val = fn(val, signalOpt);
+
+            if (val === kEmpty) {
+              continue;
+            }
+
+            val = Promise.resolve(val);
+          } catch (err) {
+            val = Promise.reject(err);
+          }
+
+          cnt += 1;
+
+          val.then(afterItemProcessed, onCatch);
+
+          queue.push(val);
+          if (next) {
+            next();
+            next = null;
+          }
+
+          if (!done && (queue.length >= highWaterMark || cnt >= concurrency)) {
+            await new Promise((resolve) => {
+              resume = resolve;
+            });
+          }
+        }
+        queue.push(kEof);
+      } catch (err) {
+        const val = Promise.reject(err);
+        val.then(afterItemProcessed, onCatch);
+        queue.push(val);
+      } finally {
+        done = true;
+        if (next) {
+          next();
+          next = null;
+        }
+      }
+    }
+
+    pump();
+
+    try {
+      while (true) {
+        while (queue.length > 0) {
+          const val = await queue[0];
+
+          if (val === kEof) {
+            return;
+          }
+
+          if (signal.aborted) {
+            throw new AbortError();
+          }
+
+          if (val !== kEmpty) {
+            yield val;
+          }
+
+          queue.shift();
+          maybeResume();
+        }
+
+        await new Promise((resolve) => {
+          next = resolve;
+        });
+      }
+    } finally {
+      done = true;
+      if (resume) {
+        resume();
+        resume = null;
+      }
+    }
+  }.call(this);
+}
+
+async function some(fn, options = undefined) {
+  for await (const unused of filter.call(this, fn, options)) {
+    return true;
+  }
+  return false;
+}
+
+async function every(fn, options = undefined) {
+  validateFunction(fn, 'fn');
+  // https://en.wikipedia.org/wiki/De_Morgan%27s_laws
+  return !(await some.call(this, async (...args) => {
+    return !(await fn(...args));
+  }, options));
+}
+
+async function find(fn, options) {
+  for await (const result of filter.call(this, fn, options)) {
+    return result;
+  }
+  return undefined;
+}
+
+async function forEach(fn, options) {
+  validateFunction(fn, 'fn');
+  async function forEachFn(value, options) {
+    await fn(value, options);
+    return kEmpty;
+  }
+  // eslint-disable-next-line no-unused-vars
+  for await (const unused of map.call(this, forEachFn, options));
+}
+
+function filter(fn, options) {
+  validateFunction(fn, 'fn');
+  async function filterFn(value, options) {
+    if (await fn(value, options)) {
+      return value;
+    }
+    return kEmpty;
+  }
+  return map.call(this, filterFn, options);
+}
+
+// Specific to provide better error to reduce since the argument is only
+// missing if the stream has no items in it - but the code is still appropriate
+class ReduceAwareErrMissingArgs extends ERR_MISSING_ARGS {
+  constructor() {
+    super('reduce');
+    this.message = 'Reduce of an empty stream requires an initial value';
+  }
+}
+
+async function reduce(reducer, initialValue, options) {
+  validateFunction(reducer, 'reducer');
+  if (options != null) {
+    validateObject(options, 'options');
+  }
+  if (options?.signal != null) {
+    validateAbortSignal(options.signal, 'options.signal');
+  }
+
+  let hasInitialValue = arguments.length > 1;
+  if (options?.signal?.aborted) {
+    const err = new AbortError(undefined, { cause: options.signal.reason });
+    this.once('error', () => {}); // The error is already propagated
+    await finished(this.destroy(err));
+    throw err;
+  }
+  const ac = new AbortController();
+  const signal = ac.signal;
+  if (options?.signal) {
+    const opts = { once: true };
+    options.signal.addEventListener('abort', () => ac.abort(), opts);
+  }
+  let gotAnyItemFromStream = false;
+  try {
+    for await (const value of this) {
+      gotAnyItemFromStream = true;
+      if (options?.signal?.aborted) {
+        throw new AbortError();
+      }
+      if (!hasInitialValue) {
+        initialValue = value;
+        hasInitialValue = true;
+      } else {
+        initialValue = await reducer(initialValue, value, { signal });
+      }
+    }
+    if (!gotAnyItemFromStream && !hasInitialValue) {
+      throw new ReduceAwareErrMissingArgs();
+    }
+  } finally {
+    ac.abort();
+  }
+  return initialValue;
+}
+
+async function toArray(options) {
+  if (options != null) {
+    validateObject(options, 'options');
+  }
+  if (options?.signal != null) {
+    validateAbortSignal(options.signal, 'options.signal');
+  }
+
+  const result = [];
+  for await (const val of this) {
+    if (options?.signal?.aborted) {
+      throw new AbortError(undefined, { cause: options.signal.reason });
+    }
+    result.push(val);
+  }
+  return result;
+}
+
+function flatMap(fn, options) {
+  const values = map.call(this, fn, options);
+  return async function* flatMap() {
+    for await (const val of values) {
+      yield* val;
+    }
+  }.call(this);
+}
+
+function toIntegerOrInfinity(number) {
+  // We coerce here to align with the spec
+  // https://github.com/tc39/proposal-iterator-helpers/issues/169
+  number = Number(number);
+  if (Number.isNaN(number)) {
+    return 0;
+  }
+  if (number < 0) {
+    throw new ERR_OUT_OF_RANGE('number', '>= 0', number);
+  }
+  return number;
+}
+
+function drop(number, options = undefined) {
+  if (options != null) {
+    validateObject(options, 'options');
+  }
+  if (options?.signal != null) {
+    validateAbortSignal(options.signal, 'options.signal');
+  }
+
+  number = toIntegerOrInfinity(number);
+  return async function* drop() {
+    if (options?.signal?.aborted) {
+      throw new AbortError();
+    }
+    for await (const val of this) {
+      if (options?.signal?.aborted) {
+        throw new AbortError();
+      }
+      if (number-- <= 0) {
+        yield val;
+      }
+    }
+  }.call(this);
+}
+
+function take(number, options = undefined) {
+  if (options != null) {
+    validateObject(options, 'options');
+  }
+  if (options?.signal != null) {
+    validateAbortSignal(options.signal, 'options.signal');
+  }
+
+  number = toIntegerOrInfinity(number);
+  return async function* take() {
+    if (options?.signal?.aborted) {
+      throw new AbortError();
+    }
+    for await (const val of this) {
+      if (options?.signal?.aborted) {
+        throw new AbortError();
+      }
+      if (number-- > 0) {
+        yield val;
+      }
+
+      // Don't get another item from iterator in case we reached the end
+      if (number <= 0) {
+        return;
+      }
+    }
+  }.call(this);
+}
+
+export const streamReturningOperators = {
+  drop,
+  filter,
+  flatMap,
+  map,
+  take,
+};
+
+export const promiseReturningOperators = {
+  every,
+  forEach,
+  reduce,
+  toArray,
+  some,
+  find,
+};