node/lib/internal/blob.js

'use strict';

const {
  ArrayFrom,
  ObjectSetPrototypeOf,
  Promise,
  PromiseResolve,
  RegExpPrototypeTest,
  StringPrototypeToLowerCase,
  Symbol,
  SymbolIterator,
  Uint8Array,
} = primordials;

const {
  createBlob,
  FixedSizeBlobCopyJob,
} = internalBinding('buffer');

const {
  JSTransferable,
  kClone,
  kDeserialize,
} = require('internal/worker/js_transferable');

const {
  isAnyArrayBuffer,
  isArrayBufferView,
} = require('internal/util/types');

const {
  customInspectSymbol: kInspect,
  emitExperimentalWarning,
} = require('internal/util');
const { inspect } = require('internal/util/inspect');

const {
  AbortError,
  codes: {
    ERR_INVALID_ARG_TYPE,
    ERR_BUFFER_TOO_LARGE,
    ERR_OUT_OF_RANGE,
  }
} = require('internal/errors');

const {
  validateObject,
  validateString,
  validateUint32,
  isUint32,
} = require('internal/validators');

const kHandle = Symbol('kHandle');
const kType = Symbol('kType');
const kLength = Symbol('kLength');

let Buffer;

function deferred() {
  let res, rej;
  const promise = new Promise((resolve, reject) => {
    res = resolve;
    rej = reject;
  });
  return { promise, resolve: res, reject: rej };
}

function lazyBuffer() {
  if (Buffer === undefined)
    Buffer = require('buffer').Buffer;
  return Buffer;
}

function isBlob(object) {
  return object?.[kHandle] !== undefined;
}

function getSource(source, encoding) {
  if (isBlob(source))
    return [source.size, source[kHandle]];

  if (typeof source === 'string') {
    source = lazyBuffer().from(source, encoding);
  } else if (isAnyArrayBuffer(source)) {
    source = new Uint8Array(source);
  } else if (!isArrayBufferView(source)) {
    throw new ERR_INVALID_ARG_TYPE(
      'source',
      [
        'string',
        'ArrayBuffer',
        'SharedArrayBuffer',
        'Buffer',
        'TypedArray',
        'DataView'
      ],
      source);
  }

  // We copy into a new Uint8Array because the underlying
  // BackingStores are going to be detached and owned by
  // the Blob. We also don't want to have to worry about
  // byte offsets.
  source = new Uint8Array(source);
  return [source.byteLength, source];
}

class InternalBlob extends JSTransferable {
  constructor(handle, length, type = '') {
    super();
    this[kHandle] = handle;
    this[kType] = type;
    this[kLength] = length;
  }
}

class Blob extends JSTransferable {
  constructor(sources = [], options) {
    emitExperimentalWarning('buffer.Blob');
    if (sources === null ||
        typeof sources[SymbolIterator] !== 'function' ||
        typeof sources === 'string') {
      throw new ERR_INVALID_ARG_TYPE('sources', 'Iterable', sources);
    }
    if (options !== undefined)
      validateObject(options, 'options');
    const {
      encoding = 'utf8',
      type = '',
    } = { ...options };

    let length = 0;
    const sources_ = ArrayFrom(sources, (source) => {
      const { 0: len, 1: src } = getSource(source, encoding);
      length += len;
      return src;
    });

    // This is a MIME media type but we're not actively checking the syntax.
    // But, to be fair, neither does Chrome.
    validateString(type, 'options.type');

    if (!isUint32(length))
      throw new ERR_BUFFER_TOO_LARGE(0xFFFFFFFF);

    super();
    this[kHandle] = createBlob(sources_, length);
    this[kLength] = length;
    this[kType] = RegExpPrototypeTest(/[^\u{0020}-\u{007E}]/u, type) ?
      '' : StringPrototypeToLowerCase(type);
  }

  [kInspect](depth, options) {
    if (depth < 0)
      return this;

    const opts = {
      ...options,
      depth: options.depth == null ? null : options.depth - 1
    };

    return `Blob ${inspect({
      size: this.size,
      type: this.type,
    }, opts)}`;
  }

  [kClone]() {
    const handle = this[kHandle];
    const type = this[kType];
    const length = this[kLength];
    return {
      data: { handle, type, length },
      deserializeInfo: 'internal/blob:InternalBlob'
    };
  }

  [kDeserialize]({ handle, type, length }) {
    this[kHandle] = handle;
    this[kType] = type;
    this[kLength] = length;
  }

  get type() { return this[kType]; }

  get size() { return this[kLength]; }

  slice(start = 0, end = (this[kLength]), type = this[kType]) {
    validateUint32(start, 'start');
    if (end < 0) end = this[kLength] + end;
    validateUint32(end, 'end');
    validateString(type, 'type');
    if (end < start)
      throw new ERR_OUT_OF_RANGE('end', 'greater than start', end);
    if (end > this[kLength])
      throw new ERR_OUT_OF_RANGE('end', 'less than or equal to length', end);
    return new InternalBlob(
      this[kHandle].slice(start, end),
      end - start, type);
  }

  async arrayBuffer() {
    const job = new FixedSizeBlobCopyJob(this[kHandle]);

    const ret = job.run();
    if (ret !== undefined)
      return PromiseResolve(ret);

    const {
      promise,
      resolve,
      reject
    } = deferred();
    job.ondone = (err, ab) => {
      if (err !== undefined)
        return reject(new AbortError());
      resolve(ab);
    };

    return promise;
  }

  async text() {
    const dec = new TextDecoder();
    return dec.decode(await this.arrayBuffer());
  }
}

InternalBlob.prototype.constructor = Blob;
ObjectSetPrototypeOf(
  InternalBlob.prototype,
  Blob.prototype);

module.exports = {
  Blob,
  InternalBlob,
  isBlob,
};