@jd-data-limited/easy-fm 4.1.0 → 4.1.2

package/src/connection/database.ts

@@ -7,13 +7,14 @@ import {generateAuthorizationHeaders} from './generateAuthorizationHeaders.js'
 import {FMError} from '../FMError.js'
 import {type LayoutInterface} from '../layouts/layoutInterface.js'
 import {Layout} from '../layouts/layout.js'
-import HTTP_REDIRECT from 'follow-redirects'
 import {type databaseOptionsBase, type databaseOptionsWithExternalSources, type Script} from '../types.js'
 import {type HostBase} from './HostBase.js'
 import {type DatabaseBase} from './databaseBase.js'
 import {type ApiLayout, type ApiResults} from '../models/apiResults.js'
 import {type DatabaseStructure} from '../databaseStructure.js'
-import {type IncomingMessage} from 'http'
+import fetch, {type HeadersInit, type RequestInfo, type RequestInit, type Response} from 'node-fetch'
+// @ts-expect-error
+import fetchWithCookies, {CookieJar} from 'node-fetch-cookies'
 
 /**
  * Represents a database connection.
@@ -23,7 +24,7 @@ export class Database<T extends DatabaseStructure> extends EventEmitter implemen
     private _token: string = ''
     readonly host: HostBase
     private readonly connection_details: databaseOptionsWithExternalSources
-    private cookies: Record<string, string> = {}
+    private cookies = new CookieJar()
     readonly name: string
     readonly debug: boolean
 
@@ -66,7 +67,6 @@ export class Database<T extends DatabaseStructure> extends EventEmitter implemen
             }
         })
         await _fetch.json()
-        // console.log(data)
         this._token = ''
     }
 
@@ -79,18 +79,17 @@ export class Database<T extends DatabaseStructure> extends EventEmitter implemen
      * @return {Promise<string>} - Returns a promise that resolves to the access token upon successful login.
      */
     async login (forceLogin = false) {
-        // console.trace()
+        if (this.token !== '' && !forceLogin) return
+
         // Reset cookies
-        this.cookies = {}
+        this.cookies = new CookieJar()
 
         await this.host.getMetadata()
-        if (this.token !== '' && !forceLogin) throw new Error('Already logged in. Run logout() first')
 
         if (this.connection_details.credentials.method === 'token') {
             this._token = (this.connection_details.credentials).token
             return this.token
         } else {
-            console.time()
             const url = new URL(`${this.endpoint}/sessions`)
             url.hostname = this.host.hostname
             const res = await fetch(url, {
@@ -103,8 +102,7 @@ export class Database<T extends DatabaseStructure> extends EventEmitter implemen
                     })
                 })
             })
-            console.time()
-            const _res = (await res.json())
+            const _res = (await res.json()) as any
             if (res.status === 200) {
                 this._token = res.headers.get('x-fm-data-access-token') ?? ''
                 return this._token
@@ -131,30 +129,53 @@ export class Database<T extends DatabaseStructure> extends EventEmitter implemen
         return `${this.host.hostname}/fmi/data/v2/databases/${this.name}`
     }
 
-    async _apiRequestRaw (url: string | Request, options: RequestInit & { headers?: Record<string, string> } = {}, autoRelogin = true): Promise<Response> {
+    async _apiRequestRaw (url: URL | RequestInfo, options: RequestInit & {
+        headers?: Record<string, string>
+        useCookieJar?: boolean
+    } = {}, autoRelogin = true): Promise<Response> {
         if (this.debug) console.log(`EASYFM DEBUG: ${JSON.stringify(options)} ${url instanceof Request ? url.url : url}`)
         if (this.token === '') await this.login(true)
 
         if (!options.headers) options.headers = {}
         options.headers.authorization = 'Bearer ' + this._token
+        // options.redirect = "manual"
+        // options.headers.cookies = this._generateCookieHeader()
+        // console.log(options.headers.cookies)
         // options.rejectUnauthorized = this.host.verify
 
-        const _fetch = await fetch(url, options)
-        if (_fetch.headers.get('set-cookie')) {
-            for (const cookie of _fetch.headers.get('set-cookie') ?? []) {
-                const cookieSplit = cookie.split('=')
-                this.cookies[cookieSplit[0]] = cookieSplit[1]
-            }
-        }
-
+        const _fetch: Response =
+            options.useCookieJar
+                ? await fetchWithCookies(this.cookies, url, options)
+                : await fetch(url, options)
+        // if (_fetch.headers.get('set-cookie')) {
+        //     console.log(_fetch.headers.get('set-cookie'))
+        //     for (const cookie of (_fetch.headers.get("Set-Cookie") ?? "").split("; ")) {
+        //         const cookieSplit = cookie.split('=')
+        //         console.log("COOKIE SPLIT:", cookieSplit)
+        //         if (cookieSplit[1]) this.cookies[cookieSplit[0]] = cookieSplit[1]
+        //     }
+        // }
+        // console.log(this.cookies, _fetch.status)
+        // // console.log(this, this.cookies, url)
+        // console.trace()
         if (_fetch.status === 401 && autoRelogin) {
+            console.trace()
             await this.login(true)
             return await this._apiRequestRaw(url, options, false)
+        } else return _fetch
+    }
+
+    private _generateCookieHeader () {
+        const out: string[] = []
+        for (const key of Object.keys(this.cookies)) {
+            out.push(`${key}=${this.cookies[key]}`)
         }
-        return _fetch
+        return out.join('; ')
     }
 
-    async _apiRequestJSON<T = any>(url: string | Request, options: RequestInit & { headers?: Record<string, string> } = {}): Promise<ApiResults<T>> {
+    async _apiRequestJSON<T = any>(url: URL | RequestInfo, options: RequestInit & {
+        headers?: Record<string, string>
+    } = {}): Promise<ApiResults<T>> {
         if (!options.headers) options.headers = {}
         options.headers['content-type'] = options.headers['content-type'] ? options.headers['content-type'] : 'application/json'
         const _fetch = await this._apiRequestRaw(url, options)
@@ -200,44 +221,6 @@ export class Database<T extends DatabaseStructure> extends EventEmitter implemen
     }
 
     script (name: string, parameter = ''): Script {
-        return ({ name, parameter } satisfies Script)
-    }
-
-    async streamURL (url: string): Promise<IncomingMessage> {
-        return await new Promise((resolve, reject) => {
-            if (!url || typeof url !== 'string') {
-                throw new Error('URL is empty, or has invalid value')
-            }
-
-            const headers: Record<string, string> = {}
-            if (Object.keys(this.cookies).length !== 0) {
-                headers.Cookie = Object.keys(this.cookies)
-                    .map(key => {
-                        return key + '=' + this.cookies[key]
-                    })
-                    .join('; ')
-            }
-
-            const checkForCookies = (res: HTTP_REDIRECT.ResponseDetails) => {
-                // Check for the 'set-cookie' header. If it exists, remember it and strip it for better security.
-                if (res.headers['set-cookie']) {
-                    for (const cookie of res.headers['set-cookie']) {
-                        const cookieSplit = cookie.split('=')
-                        this.cookies[cookieSplit[0]] = cookieSplit[1]
-                    }
-                    res.headers['set-cookie'] = undefined
-                }
-            }
-
-            // Automatically switch between the http and https modules, based on which is needed
-            (url.startsWith('https') ? HTTP_REDIRECT.https : HTTP_REDIRECT.http).get(url, {
-                headers,
-                beforeRedirect: (options: any, res: HTTP_REDIRECT.ResponseDetails) => { checkForCookies(res) }
-            }, (res) => {
-                checkForCookies(res)
-
-                resolve(res)
-            })
-        })
+        return ({name, parameter} satisfies Script)
     }
 }

package/src/connection/databaseBase.d.ts

@@ -1,17 +1,16 @@
-/// <reference types="node" resolution-mode="require"/>
 import { type HostBase } from './HostBase.js';
 import { type ApiResults } from '../models/apiResults.js';
-import { type IncomingMessage } from 'http';
+import { type RequestInfo, type RequestInit, type Response } from 'node-fetch';
 export interface DatabaseBase {
     host: HostBase;
     readonly name: string;
     endpoint: string;
     token: string;
-    _apiRequestJSON: <T = unknown>(url: string | Request, options?: RequestInit & {
+    _apiRequestJSON: <T = unknown>(url: URL | RequestInfo, options?: RequestInit & {
         headers?: Record<string, string>;
     } | undefined, autoRelogin?: boolean) => Promise<ApiResults<T>>;
-    _apiRequestRaw: (url: string | Request, options?: RequestInit & {
+    _apiRequestRaw: (url: URL | RequestInfo, options?: RequestInit & {
         headers?: Record<string, string>;
+        useCookieJar?: boolean;
     } | undefined) => Promise<Response>;
-    streamURL: (url: string) => Promise<IncomingMessage>;
 }

package/src/connection/databaseBase.ts

@@ -4,7 +4,7 @@
 
 import {type HostBase} from './HostBase.js'
 import {type ApiResults} from '../models/apiResults.js'
-import {type IncomingMessage} from 'http'
+import {type RequestInfo, type RequestInit, type Response} from 'node-fetch'
 
 export interface DatabaseBase {
     host: HostBase
@@ -14,7 +14,6 @@ export interface DatabaseBase {
 
     // layouts: DatabaseStructure["layouts"]
 
-    _apiRequestJSON: <T = unknown>(url: string | Request, options?: RequestInit & { headers?: Record<string, string> } | undefined, autoRelogin?: boolean) => Promise<ApiResults<T>>
-    _apiRequestRaw: (url: string | Request, options?: RequestInit & { headers?: Record<string, string> } | undefined) => Promise<Response>
-    streamURL: (url: string) => Promise<IncomingMessage>
+    _apiRequestJSON: <T = unknown>(url: URL | RequestInfo, options?: RequestInit & { headers?: Record<string, string> } | undefined, autoRelogin?: boolean) => Promise<ApiResults<T>>
+    _apiRequestRaw: (url: URL | RequestInfo, options?: RequestInit & { headers?: Record<string, string>, useCookieJar?: boolean } | undefined) => Promise<Response>
 }

package/src/records/field.d.ts

@@ -1,7 +1,5 @@
-/// <reference types="node" resolution-mode="require"/>
-/// <reference types="node" resolution-mode="require"/>
-import type * as http from 'http';
-import { type ContainerBufferResult, DownloadModes, RecordTypes } from '../types.js';
+/// <reference types="node" />
+import { RecordTypes } from '../types.js';
 import { type ApiFieldMetadata } from '../models/apiResults.js';
 import { type LayoutBase } from '../layouts/layoutBase.js';
 import { type Moment } from 'moment';
@@ -21,10 +19,12 @@ export interface Parentable {
  * @template T - The type of the field value.
  */
 export declare class Field<T extends FieldValue> {
+    #private;
     parent: Parentable;
     id: string;
     protected _value: T | null;
     edited: boolean;
+    static firstContainerDownload: Promise<any> | null;
     constructor(record: Parentable, id: string, contents: T);
     /**
      * Sets the value of the field.
@@ -40,22 +40,14 @@ export declare class Field<T extends FieldValue> {
     /**
      * Uploads a file to the container field.
      *
-     * @param {Buffer} buffer - The file content as a buffer.
-     * @param {string} filename - The filename of the file.
-     * @param {string} mime - The MIME type of the file.
+     * @param {Buffer} file - The file content as a buffer.
      *
      * @throws {Error} - Cannot upload a file to the field if it's not a container field.
      * @throws {Error} - Upload failed with HTTP error.
      *
      * @returns {Promise<void>} - A promise that resolves when the file is successfully uploaded.
      */
-    upload(buffer: Buffer, filename: string, mime: string): Promise<void>;
-    /**
-     * Downloads a resource from the server using the specified download mode.
-     *
-     * @param {DownloadModes} mode - The mode to use for downloading the resource.
-     * @return {Promise<http.IncomingMessage>} - A promise that resolves with the incoming message representing the downloaded resource.
-     */
-    download(mode: DownloadModes.Stream): Promise<http.IncomingMessage>;
-    download(mode: DownloadModes.Buffer): Promise<ContainerBufferResult>;
+    upload(file: File): Promise<void>;
+    stream(): Promise<NodeJS.ReadableStream>;
+    arrayBuffer(): Promise<ArrayBuffer>;
 }

package/src/records/field.js

@@ -1,60 +1,100 @@
 /*
  * Copyright (c) 2023-2024. See LICENSE file for more information
  */
-import { DownloadModes, RecordTypes } from '../types.js';
+var __runInitializers = (this && this.__runInitializers) || function (thisArg, initializers, value) {
+    var useValue = arguments.length > 2;
+    for (var i = 0; i < initializers.length; i++) {
+        value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);
+    }
+    return useValue ? value : void 0;
+};
+var __esDecorate = (this && this.__esDecorate) || function (ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {
+    function accept(f) { if (f !== void 0 && typeof f !== "function") throw new TypeError("Function expected"); return f; }
+    var kind = contextIn.kind, key = kind === "getter" ? "get" : kind === "setter" ? "set" : "value";
+    var target = !descriptorIn && ctor ? contextIn["static"] ? ctor : ctor.prototype : null;
+    var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});
+    var _, done = false;
+    for (var i = decorators.length - 1; i >= 0; i--) {
+        var context = {};
+        for (var p in contextIn) context[p] = p === "access" ? {} : contextIn[p];
+        for (var p in contextIn.access) context.access[p] = contextIn.access[p];
+        context.addInitializer = function (f) { if (done) throw new TypeError("Cannot add initializers after decoration has completed"); extraInitializers.push(accept(f || null)); };
+        var result = (0, decorators[i])(kind === "accessor" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);
+        if (kind === "accessor") {
+            if (result === void 0) continue;
+            if (result === null || typeof result !== "object") throw new TypeError("Object expected");
+            if (_ = accept(result.get)) descriptor.get = _;
+            if (_ = accept(result.set)) descriptor.set = _;
+            if (_ = accept(result.init)) initializers.unshift(_);
+        }
+        else if (_ = accept(result)) {
+            if (kind === "field") initializers.unshift(_);
+            else descriptor[key] = _;
+        }
+    }
+    if (target) Object.defineProperty(target, contextIn.name, descriptor);
+    done = true;
+};
+var __setFunctionName = (this && this.__setFunctionName) || function (f, name, prefix) {
+    if (typeof name === "symbol") name = name.description ? "[".concat(name.description, "]") : "";
+    return Object.defineProperty(f, "name", { configurable: true, value: prefix ? "".concat(prefix, " ", name) : name });
+};
+import { RecordTypes } from '../types.js';
 import { ApiFieldDisplayTypes, ApiFieldResultTypes, ApiFieldTypes } from '../models/apiResults.js';
+import { FMError } from '../FMError.js';
 /**
  * A class representing a field in a record.
  *
  * @template T - The type of the field value.
  */
-export class Field {
-    parent;
-    id;
-    _value;
-    edited;
-    constructor(record, id, contents) {
-        this.parent = record;
-        this.id = id;
-        this._value = contents;
-        this.edited = false;
-    }
-    /**
-     * Sets the value of the field.
-     *
-     * @param {T | null} content - The new content value to be set. Can be either the type T or null.
-     * @throws {Error} Cannot set container value using set(). Use upload() instead, if the result is a 'container'.
-     */
-    set(content) {
-        if (this.metadata.result === 'container')
-            throw new Error('Cannot set container value using set(). Use upload() instead.');
-        else
-            this._value = content;
-        this.edited = true;
-    }
-    get metadata() {
-        if (!this.parent.layout.metadata) {
-            // Default to a regular text field
-            return {
-                name: this.id.toString(),
-                type: ApiFieldTypes.NORMAL,
-                displayType: ApiFieldDisplayTypes.EDIT_TEXT,
-                result: ApiFieldResultTypes.TEXT,
-                global: false,
-                autoEnter: true,
-                fourDigitYear: false,
-                maxRepeat: 1,
-                maxCharacters: 0,
-                notEmpty: false,
-                numeric: false,
-                timeOfDay: false,
-                repetitions: 1,
-                valueList: ''
-            };
+let Field = (() => {
+    let _instanceExtraInitializers = [];
+    let _private_streamAsync_decorators;
+    let _private_streamAsync_descriptor;
+    let _arrayBuffer_decorators;
+    return class Field {
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(null) : void 0;
+            _private_streamAsync_decorators = [containerDownloadFunction];
+            _arrayBuffer_decorators = [containerDownloadFunction];
+            __esDecorate(this, _private_streamAsync_descriptor = { value: __setFunctionName(async function () {
+                    const req = await this.parent.layout.database._apiRequestRaw(this.string, { useCookieJar: true });
+                    if (!req.ok || !req.body) {
+                        throw new Error(`HTTP Error: ${req.status} (${req.statusText})`);
+                    }
+                    return req.body;
+                }, "#streamAsync") }, _private_streamAsync_decorators, { kind: "method", name: "#streamAsync", static: false, private: true, access: { has: obj => #streamAsync in obj, get: obj => obj.#streamAsync }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _arrayBuffer_decorators, { kind: "method", name: "arrayBuffer", static: false, private: false, access: { has: obj => "arrayBuffer" in obj, get: obj => obj.arrayBuffer }, metadata: _metadata }, null, _instanceExtraInitializers);
+            if (_metadata) Object.defineProperty(this, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+        }
+        parent = __runInitializers(this, _instanceExtraInitializers);
+        id;
+        _value;
+        edited;
+        static firstContainerDownload = null;
+        constructor(record, id, contents) {
+            this.parent = record;
+            this.id = id;
+            this._value = contents;
+            this.edited = false;
         }
-        if (this.parent.type === RecordTypes.PORTAL && this.parent.portal) {
-            return this.parent.layout.metadata.portalMetaData[this.parent.portal.name || 'portal not attached'].find(i => i.name === this.id) ??
-                {
+        /**
+         * Sets the value of the field.
+         *
+         * @param {T | null} content - The new content value to be set. Can be either the type T or null.
+         * @throws {Error} Cannot set container value using set(). Use upload() instead, if the result is a 'container'.
+         */
+        set(content) {
+            if (this.metadata.result === 'container')
+                throw new Error('Cannot set container value using set(). Use upload() instead.');
+            else
+                this._value = content;
+            this.edited = true;
+        }
+        get metadata() {
+            if (!this.parent.layout.metadata) {
+                // Default to a regular text field
+                return {
                     name: this.id.toString(),
                     type: ApiFieldTypes.NORMAL,
                     displayType: ApiFieldDisplayTypes.EDIT_TEXT,
@@ -70,90 +110,151 @@ export class Field {
                     repetitions: 1,
                     valueList: ''
                 };
+            }
+            if (this.parent.type === RecordTypes.PORTAL && this.parent.portal) {
+                return this.parent.layout.metadata.portalMetaData[this.parent.portal.name || 'portal not attached'].find(i => i.name === this.id) ??
+                    {
+                        name: this.id.toString(),
+                        type: ApiFieldTypes.NORMAL,
+                        displayType: ApiFieldDisplayTypes.EDIT_TEXT,
+                        result: ApiFieldResultTypes.TEXT,
+                        global: false,
+                        autoEnter: true,
+                        fourDigitYear: false,
+                        maxRepeat: 1,
+                        maxCharacters: 0,
+                        notEmpty: false,
+                        numeric: false,
+                        timeOfDay: false,
+                        repetitions: 1,
+                        valueList: ''
+                    };
+            }
+            else {
+                return this.parent.layout.metadata.fieldMetaData.find(i => i.name === this.id) ?? {
+                    name: this.id.toString(),
+                    type: ApiFieldTypes.NORMAL,
+                    displayType: ApiFieldDisplayTypes.EDIT_TEXT,
+                    result: ApiFieldResultTypes.TEXT,
+                    global: false,
+                    autoEnter: true,
+                    fourDigitYear: false,
+                    maxRepeat: 1,
+                    maxCharacters: 0,
+                    notEmpty: false,
+                    numeric: false,
+                    timeOfDay: false,
+                    repetitions: 1,
+                    valueList: ''
+                };
+            }
         }
-        else {
-            return this.parent.layout.metadata.fieldMetaData.find(i => i.name === this.id) ?? {
-                name: this.id.toString(),
-                type: ApiFieldTypes.NORMAL,
-                displayType: ApiFieldDisplayTypes.EDIT_TEXT,
-                result: ApiFieldResultTypes.TEXT,
-                global: false,
-                autoEnter: true,
-                fourDigitYear: false,
-                maxRepeat: 1,
-                maxCharacters: 0,
-                notEmpty: false,
-                numeric: false,
-                timeOfDay: false,
-                repetitions: 1,
-                valueList: ''
-            };
-        }
-    }
-    get value() {
-        // if (this.metadata.result === "container") throw "Use await field.stream() to get the contents of a container field, instead of field.value"
-        return this._value;
-    }
-    set value(value) {
-        this._value = value;
-    }
-    get string() {
-        if (typeof this._value === 'string') {
+        get value() {
+            // if (this.metadata.result === "container") throw "Use await field.stream() to get the contents of a container field, instead of field.value"
             return this._value;
         }
-        throw new Error('Field value is not a string');
-    }
-    /**
-     * Uploads a file to the container field.
-     *
-     * @param {Buffer} buffer - The file content as a buffer.
-     * @param {string} filename - The filename of the file.
-     * @param {string} mime - The MIME type of the file.
-     *
-     * @throws {Error} - Cannot upload a file to the field if it's not a container field.
-     * @throws {Error} - Upload failed with HTTP error.
-     *
-     * @returns {Promise<void>} - A promise that resolves when the file is successfully uploaded.
-     */
-    async upload(buffer, filename, mime) {
-        if (this.metadata.result !== 'container') {
-            throw new Error('Cannot upload a file to the field; ' + this.id + ' (not a container field)');
+        set value(value) {
+            this._value = value;
         }
-        const form = new FormData();
-        form.append('upload', new File([buffer], filename, { type: mime }));
-        const res = await this.parent.layout.database._apiRequestRaw(`${this.parent.endpoint}/containers/${this.id}/1`, {
-            method: 'POST',
-            headers: {
-                Authorization: 'Bearer ' + this.parent.layout.database.token,
-                'Content-Type': 'multipart/form-data'
-            },
-            body: form
-        });
-        if (!res.ok)
-            throw new Error(`Upload failed with HTTP error: ${res.status} (${res.statusText})`);
-    }
-    async download(mode = DownloadModes.Stream) {
-        if (this.metadata.result !== ApiFieldResultTypes.CONTAINER)
-            throw new Error('Cannot perform download() on a non-container field');
-        const stream = await this.parent.layout.database.streamURL(this.string);
-        if (mode === DownloadModes.Stream) {
-            return stream;
+        get string() {
+            if (typeof this._value === 'string') {
+                return this._value;
+            }
+            throw new Error('Field value is not a string');
         }
-        const body = [];
-        return await new Promise((resolve, reject) => {
-            stream.on('data', (chunk) => {
-                body.push(chunk);
+        /**
+         * Uploads a file to the container field.
+         *
+         * @param {Buffer} file - The file content as a buffer.
+         *
+         * @throws {Error} - Cannot upload a file to the field if it's not a container field.
+         * @throws {Error} - Upload failed with HTTP error.
+         *
+         * @returns {Promise<void>} - A promise that resolves when the file is successfully uploaded.
+         */
+        async upload(file) {
+            if (this.metadata.result !== 'container') {
+                throw new Error('Cannot upload a file to the field; ' + this.id + ' (not a container field)');
+            }
+            const form = new FormData();
+            form.append('upload', file);
+            const res = await this.parent.layout.database._apiRequestRaw(`${this.parent.endpoint}/containers/${this.id}/1`, {
+                method: 'POST',
+                headers: {
+                // Authorization: 'Bearer ' + this.parent.layout.database.token,
+                // 'Content-Type': 'multipart/form-data'
+                },
+                body: form
             });
-            stream.on('error', (e) => {
-                reject(e);
-            });
-            stream.on('end', () => {
-                resolve({
-                    buffer: Buffer.concat(body),
-                    mime: stream.headers['content-type'],
-                    request: stream
+            if (!res.ok) {
+                throw new Error(`Upload failed with HTTP error: ${res.status} (${res.statusText})`);
+            }
+            const data = await res.json();
+            if (data.messages[0].code === '0')
+                return;
+            else {
+                throw new FMError(data.messages[0].code, res.status, res);
+            }
+        }
+        get #streamAsync() { return _private_streamAsync_descriptor.value; }
+        async stream() {
+            return await this.#streamAsync();
+        }
+        async arrayBuffer() {
+            const req = await this.parent.layout.database._apiRequestRaw(this.string, { useCookieJar: true });
+            if (!req.ok)
+                throw new Error(`HTTP Error: ${req.status} (${req.statusText})`);
+            return await req.arrayBuffer();
+        }
+    };
+})();
+export { Field };
+function containerDownloadFunction(originalMethod, context) {
+    async function replacementMethod(...args) {
+        return await ContainerDownloadExecutor.processTask(async () => await originalMethod.call(this, ...args));
+    }
+    return replacementMethod;
+}
+class ContainerDownloadExecutorClass {
+    hasDownloadedFirstContainer = 0;
+    waitingFuncs = [];
+    async processTask(task) {
+        const isFirstTask = this.hasDownloadedFirstContainer === 0;
+        if (isFirstTask) {
+            this.hasDownloadedFirstContainer = 1;
+            let res;
+            try {
+                res = await task();
+            }
+            catch (e) {
+                this.hasDownloadedFirstContainer = 0;
+                const nextTask = this.waitingFuncs.splice(0, 1)[0];
+                if (nextTask) {
+                    this.processTask(nextTask.func)
+                        .then(res => nextTask.done(res))
+                        .catch(e => nextTask.err(e));
+                }
+                throw e;
+            }
+            this.hasDownloadedFirstContainer = 2;
+            for (const task of this.waitingFuncs) {
+                task.func()
+                    .then((res) => task.done(res))
+                    .catch((e) => task.err(e));
+            }
+            return res;
+        }
+        else if (this.hasDownloadedFirstContainer === 1) {
+            return await new Promise((resolve, reject) => {
+                this.waitingFuncs.push({
+                    func: task,
+                    done: resolve,
+                    err: reject
                 });
             });
-        });
+        }
+        else
+            return await task();
     }
 }
+const ContainerDownloadExecutor = new ContainerDownloadExecutorClass();