edge-mock/models/Blob.js

types for testing an developer edge applications

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.EdgeFile = exports.EdgeBlob = void 0;
// https://developer.mozilla.org/en-US/docs/Web/API/Blob
const utils_1 = require("../utils");
const ReadableStream_1 = require("./ReadableStream");
class EdgeBlob {
    type;
    _parts;
    _encoding;
    constructor(parts, { type, encoding } = {}) {
        this._parts = parts;
        this.type = type || '';
        this._encoding = encoding || 'utf8'; // currently unused
    }
    get size() {
        let size = 0;
        for (const part of this._parts) {
            if (typeof part == 'string') {
                size += utils_1.encode(part).length;
            }
            else if ('size' in part) {
                size += part.size;
            }
            else {
                size += part.byteLength;
            }
        }
        return size;
    }
    async text() {
        return utils_1.decode(await this.arrayBuffer());
    }
    async arrayBuffer() {
        const buffers_views = await Promise.all(this._parts.map(partToArrayBufferView));
        return utils_1.catArraysBufferViews(buffers_views).buffer;
    }
    stream() {
        const iterator = this._parts[Symbol.iterator]();
        return new ReadableStream_1.EdgeReadableStream({
            async pull(controller) {
                const { value, done } = iterator.next();
                if (done) {
                    controller.close();
                }
                else {
                    const buffer_view = await partToArrayBufferView(value);
                    controller.enqueue(buffer_view);
                }
            },
        });
    }
    slice(start = 0, end = undefined, contentType) {
        const size = this.size;
        if (start < 0) {
            start = size + start;
        }
        end = end || size;
        if (end < 0) {
            end = size + end;
        }
        const options = contentType ? { type: contentType } : {};
        let offset = 0;
        if (end <= start) {
            return new EdgeBlob([], options);
        }
        const new_parts = [];
        for (const part of this._parts) {
            if (end <= offset) {
                break;
            }
            let part_array;
            let part_size;
            if (typeof part == 'string') {
                part_array = utils_1.encode(part);
                part_size = part_array.byteLength;
            }
            else if ('arrayBuffer' in part) {
                part_array = part;
                part_size = part_array.size;
            }
            else {
                part_array = part;
                part_size = part_array.byteLength;
            }
            if (start < offset + part_size) {
                new_parts.push(part_array.slice(Math.max(0, start - offset), end - offset));
            }
            offset += part_size;
        }
        return new EdgeBlob(new_parts, options);
    }
}
exports.EdgeBlob = EdgeBlob;
class EdgeFile extends EdgeBlob {
    lastModified;
    name;
    constructor(fileBits, fileName, options) {
        super(fileBits, options);
        this.name = fileName;
        this.lastModified = options?.lastModified || new Date().getTime();
    }
}
exports.EdgeFile = EdgeFile;
async function partToArrayBufferView(part) {
    if (typeof part == 'string') {
        return utils_1.encode(part);
    }
    else if ('buffer' in part) {
        return part;
    }
    else if ('byteLength' in part) {
        return new Uint8Array(part);
    }
    else {
        return new Uint8Array(await part.arrayBuffer());
    }
}
//# sourceMappingURL=Blob.js.map