denoland-deno/cli/js/streams/shared-internals.ts

// Forked from https://github.com/stardazed/sd-streams/tree/8928cf04b035fd02fb1340b7eb541c76be37e546
// Copyright (c) 2018-Present by Arthur Langereis - @zenmumbler MIT

/**
 * streams/shared-internals - common types and methods for streams
 * Part of Stardazed
 * (c) 2018-Present by Arthur Langereis - @zenmumbler
 * https://github.com/stardazed/sd-streams
 */

/* eslint-disable @typescript-eslint/no-explicit-any */
// TODO don't disable this warning

import { AbortSignal, QueuingStrategySizeCallback } from "../dom_types.ts";

// common stream fields

export const state_ = Symbol("state_");
export const storedError_ = Symbol("storedError_");

// ---------

/** An error reason / result can be anything */
export type ErrorResult = any;

// ---------

export function isInteger(value: number): boolean {
  if (!isFinite(value)) {
    // covers NaN, +Infinity and -Infinity
    return false;
  }
  const absValue = Math.abs(value);
  return Math.floor(absValue) === absValue;
}

export function isFiniteNonNegativeNumber(value: unknown): boolean {
  if (!(typeof value === "number" && isFinite(value))) {
    // covers NaN, +Infinity and -Infinity
    return false;
  }
  return value >= 0;
}

export function isAbortSignal(signal: any): signal is AbortSignal {
  if (typeof signal !== "object" || signal === null) {
    return false;
  }
  try {
    // TODO
    // calling signal.aborted() probably isn't the right way to perform this test
    // https://github.com/stardazed/sd-streams/blob/master/packages/streams/src/shared-internals.ts#L41
    signal.aborted();
    return true;
  } catch (err) {
    return false;
  }
}

export function invokeOrNoop<O extends object, P extends keyof O>(
  o: O,
  p: P,
  args: any[]
): any {
  // Assert: O is not undefined.
  // Assert: IsPropertyKey(P) is true.
  // Assert: args is a List.
  const method: Function | undefined = (o as any)[p]; // tslint:disable-line:ban-types
  if (method === undefined) {
    return undefined;
  }
  return Function.prototype.apply.call(method, o, args);
}

export function cloneArrayBuffer(
  srcBuffer: ArrayBufferLike,
  srcByteOffset: number,
  srcLength: number,
  cloneConstructor: ArrayBufferConstructor | SharedArrayBufferConstructor
): InstanceType<typeof cloneConstructor> {
  // this function fudges the return type but SharedArrayBuffer is disabled for a while anyway
  return srcBuffer.slice(
    srcByteOffset,
    srcByteOffset + srcLength
  ) as InstanceType<typeof cloneConstructor>;
}

export function transferArrayBuffer(buffer: ArrayBufferLike): ArrayBuffer {
  // This would in a JS engine context detach the buffer's backing store and return
  // a new ArrayBuffer with the same backing store, invalidating `buffer`,
  // i.e. a move operation in C++ parlance.
  // Sadly ArrayBuffer.transfer is yet to be implemented by a single browser vendor.
  return buffer.slice(0); // copies instead of moves
}

export function copyDataBlockBytes(
  toBlock: ArrayBufferLike,
  toIndex: number,
  fromBlock: ArrayBufferLike,
  fromIndex: number,
  count: number
): void {
  new Uint8Array(toBlock, toIndex, count).set(
    new Uint8Array(fromBlock, fromIndex, count)
  );
}

// helper memoisation map for object values
// weak so it doesn't keep memoized versions of old objects indefinitely.
const objectCloneMemo = new WeakMap<object, object>();

let sharedArrayBufferSupported_: boolean | undefined;
function supportsSharedArrayBuffer(): boolean {
  if (sharedArrayBufferSupported_ === undefined) {
    try {
      new SharedArrayBuffer(16);
      sharedArrayBufferSupported_ = true;
    } catch (e) {
      sharedArrayBufferSupported_ = false;
    }
  }
  return sharedArrayBufferSupported_;
}

/**
 * Implement a method of value cloning that is reasonably close to performing `StructuredSerialize(StructuredDeserialize(value))`
 * from the HTML standard. Used by the internal `readableStreamTee` method to clone values for connected implementations.
 * @see https://html.spec.whatwg.org/multipage/structured-data.html#structuredserializeinternal
 */
export function cloneValue(value: any): any {
  const valueType = typeof value;
  switch (valueType) {
    case "number":
    case "string":
    case "boolean":
    case "undefined":
    // @ts-ignore
    case "bigint":
      return value;
    case "object": {
      if (objectCloneMemo.has(value)) {
        return objectCloneMemo.get(value);
      }
      if (value === null) {
        return value;
      }
      if (value instanceof Date) {
        return new Date(value.valueOf());
      }
      if (value instanceof RegExp) {
        return new RegExp(value);
      }
      if (supportsSharedArrayBuffer() && value instanceof SharedArrayBuffer) {
        return value;
      }
      if (value instanceof ArrayBuffer) {
        const cloned = cloneArrayBuffer(
          value,
          0,
          value.byteLength,
          ArrayBuffer
        );
        objectCloneMemo.set(value, cloned);
        return cloned;
      }
      if (ArrayBuffer.isView(value)) {
        const clonedBuffer = cloneValue(value.buffer) as ArrayBufferLike;
        // Use DataViewConstructor type purely for type-checking, can be a DataView or TypedArray.
        // They use the same constructor signature, only DataView has a length in bytes and TypedArrays
        // use a length in terms of elements, so we adjust for that.
        let length: number;
        if (value instanceof DataView) {
          length = value.byteLength;
        } else {
          length = (value as Uint8Array).length;
        }
        return new (value.constructor as DataViewConstructor)(
          clonedBuffer,
          value.byteOffset,
          length
        );
      }
      if (value instanceof Map) {
        const clonedMap = new Map();
        objectCloneMemo.set(value, clonedMap);
        value.forEach((v, k) => clonedMap.set(k, cloneValue(v)));
        return clonedMap;
      }
      if (value instanceof Set) {
        const clonedSet = new Map();
        objectCloneMemo.set(value, clonedSet);
        value.forEach((v, k) => clonedSet.set(k, cloneValue(v)));
        return clonedSet;
      }

      // generic object
      const clonedObj = {} as any;
      objectCloneMemo.set(value, clonedObj);
      const sourceKeys = Object.getOwnPropertyNames(value);
      for (const key of sourceKeys) {
        clonedObj[key] = cloneValue(value[key]);
      }
      return clonedObj;
    }
    case "symbol":
    case "function":
    default:
      // TODO this should be a DOMException,
      // https://github.com/stardazed/sd-streams/blob/master/packages/streams/src/shared-internals.ts#L171
      throw new Error("Uncloneable value in stream");
  }
}

export function promiseCall<F extends Function>(
  f: F,
  v: object | undefined,
  args: any[]
): Promise<any> {
  // tslint:disable-line:ban-types
  try {
    const result = Function.prototype.apply.call(f, v, args);
    return Promise.resolve(result);
  } catch (err) {
    return Promise.reject(err);
  }
}

export function createAlgorithmFromUnderlyingMethod<
  O extends object,
  K extends keyof O
>(obj: O, methodName: K, extraArgs: any[]): any {
  const method = obj[methodName];
  if (method === undefined) {
    return (): any => Promise.resolve(undefined);
  }
  if (typeof method !== "function") {
    throw new TypeError(`Field "${methodName}" is not a function.`);
  }
  return function(...fnArgs: any[]): any {
    return promiseCall(method, obj, fnArgs.concat(extraArgs));
  };
}

/*
Deprecated for now, all usages replaced by readableStreamCreateReadResult

function createIterResultObject<T>(value: T, done: boolean): IteratorResult<T> {
	return { value, done };
}
*/

export function validateAndNormalizeHighWaterMark(hwm: unknown): number {
  const highWaterMark = Number(hwm);
  if (isNaN(highWaterMark) || highWaterMark < 0) {
    throw new RangeError(
      "highWaterMark must be a valid, non-negative integer."
    );
  }
  return highWaterMark;
}

export function makeSizeAlgorithmFromSizeFunction<T>(
  sizeFn: undefined | ((chunk: T) => number)
): QueuingStrategySizeCallback<T> {
  if (typeof sizeFn !== "function" && typeof sizeFn !== "undefined") {
    throw new TypeError("size function must be undefined or a function");
  }
  return function(chunk: T): number {
    if (typeof sizeFn === "function") {
      return sizeFn(chunk);
    }
    return 1;
  };
}

// ----

export const enum ControlledPromiseState {
  Pending,
  Resolved,
  Rejected
}

export interface ControlledPromise<V> {
  resolve(value?: V): void;
  reject(error: ErrorResult): void;
  promise: Promise<V>;
  state: ControlledPromiseState;
}

export function createControlledPromise<V>(): ControlledPromise<V> {
  const conProm = {
    state: ControlledPromiseState.Pending
  } as ControlledPromise<V>;
  conProm.promise = new Promise<V>(function(resolve, reject) {
    conProm.resolve = function(v?: V): void {
      conProm.state = ControlledPromiseState.Resolved;
      resolve(v);
    };
    conProm.reject = function(e?: ErrorResult): void {
      conProm.state = ControlledPromiseState.Rejected;
      reject(e);
    };
  });
  return conProm;
}