@cirrobio/sdk 0.4.2 → 0.9.0

package/dist/index.esm.js

@@ -0,0 +1,759 @@
+import { ProjectAccessType, Configuration, AuditApi, BillingApi, ComputeEnvironmentApi, DatasetsApi, ExecutionApi, FileApi, GovernanceApi, MetadataApi, NotebooksApi, ProcessesApi, ProjectRequestsApi, ProjectsApi, ReferencesApi, SharingApi, SystemApi, ToolsApi, UsersApi } from '@cirrobio/api-client';
+import { S3Client, GetObjectCommand, DeleteObjectCommand } from '@aws-sdk/client-s3';
+import { getSignedUrl as getSignedUrl$1 } from '@aws-sdk/s3-request-presigner';
+import { Upload } from '@aws-sdk/lib-storage';
+export { Upload } from '@aws-sdk/lib-storage';
+import { v4 } from 'uuid';
+
+/**
+ * An array of file extensions that can be rendered in a genome viewer
+ */
+const FILE_TRACK_ANNOTATION = ['bed', 'bed.gz', 'gtf', 'gtf.gz'];
+const FILE_TRACK_ALIGNMENTS = ['cram', 'cram.gz']; // TODO: put back bam
+const FILE_TRACK_VARIANT = ['vcf', 'vcf.gz'];
+const FILE_TRACK_WIG = ['wig', 'wig.gz', 'bw', 'bw.gz', 'bigwig', 'bigwig.gz'];
+const FILE_TRACK_SEG = ['seg', 'seg.gz'];
+const FILE_TRACK_INDEX_EXTENSIONS = ['tbi', 'bai', 'crai', 'csi'];
+const FILE_VITESSCE_EXTENSIONS = ['hdf5', 'h5ad', 'loom'];
+const FILE_TRACK_EXTENSIONS_NO_INDEX = [
+    ...FILE_TRACK_ANNOTATION,
+    ...FILE_TRACK_ALIGNMENTS,
+    ...FILE_TRACK_VARIANT,
+    ...FILE_TRACK_WIG,
+    ...FILE_TRACK_SEG
+];
+const FILE_TRACK_EXTENSIONS = [
+    ...FILE_TRACK_EXTENSIONS_NO_INDEX,
+    ...FILE_TRACK_INDEX_EXTENSIONS
+];
+const FILE_BROWSER_EXTENSIONS = ['html', 'pdf'];
+/**
+ * An array of file extensions that are protein structure files.
+ */
+const FILE_PROTEIN_STRUCTURE_EXTENSIONS = ['pdb', 'pdb.gz', 'cif', 'cif.gz', 'ent', 'ent.gz', 'mmtf', 'mmtf.gz'];
+/**
+ * An array of file extensions that are considered tabular files.
+ */
+const FILE_DSV_EXTENSIONS = ['tab', 'csv', 'tsv', 'dsv'];
+/**
+ * An array of file extensions that contain genomic sequence content.
+ */
+const FILE_TXT_GENOMICS_EXTENSIONS = ['fasta', 'fna', 'fsa', 'fa', 'fastp', 'fastq', 'faa', 'gbk', 'gff', 'vcf', 'seq'];
+/**
+ * An array of file extensions that are considered TXT files.
+ */
+const FILE_TXT_EXTENSIONS = ['txt', 'log', 'yml', 'cfg', 'config', 'xml', 'yaml', ...FILE_DSV_EXTENSIONS, ...FILE_TXT_GENOMICS_EXTENSIONS];
+/**
+ * An array of file extensions that are considered image files.
+ */
+const FILE_IMAGE_EXTENSIONS = ['jpg', 'jpeg', 'png', 'svg'];
+/**
+ * An array of file extensions that are considered OME (Open Microscopy Environment) files.
+ */
+const FILE_OME_EXTENSIONS = ['tif', 'ome.tif', 'ome.tiff', 'ome.tif.gz', 'ome.tiff.gz'];
+/**
+ * An array of file extensions that can be opened in the browser.
+ * Includes common document formats such as HTML, PDF, and JSON, as well as image, DSV, TXT, and OME file formats.
+ */
+const FILE_EXTENSIONS_TO_OPEN = ['html', 'pdf', 'json', 'fcs',
+    ...FILE_IMAGE_EXTENSIONS,
+    ...FILE_TXT_EXTENSIONS,
+    ...FILE_TRACK_EXTENSIONS,
+    ...FILE_PROTEIN_STRUCTURE_EXTENSIONS
+];
+/**
+ * Checks if a file has an extension that matches one in the provided list.
+ * @param filePath The file to check the extension of.
+ * @param extensions A list of file endings to check the file against.
+ * @returns True or false if the file has an ending in the extensions list.
+ */
+function matchesExtension(filePath, extensions) {
+    filePath = filePath.toLowerCase();
+    // Decompress the filePath if it ends with .gz
+    if (filePath.endsWith('.gz')) {
+        filePath = filePath.slice(0, -3); // remove the .gz extension
+    }
+    // Now, get the extension of the file
+    const fileExtension = filePath.slice(filePath.lastIndexOf('.') + 1);
+    // Check if the fileExtension is in the list of extensions
+    return extensions.includes(fileExtension);
+}
+
+class Mutex {
+    constructor() {
+        this.mutex = Promise.resolve();
+    }
+    lock() {
+        let begin = () => { };
+        this.mutex = this.mutex.then(() => new Promise(begin));
+        return new Promise((res) => {
+            begin = res;
+        });
+    }
+    async dispatch(fn) {
+        const unlock = await this.lock();
+        try {
+            return await Promise.resolve(fn());
+        }
+        finally {
+            unlock();
+        }
+    }
+}
+/**
+ * A mutex to ensure that only one request for credentials is made at a time.
+ */
+const credentialsMutex = new Mutex();
+/**
+ * A cache of credentials to avoid making multiple requests for the same credentials.
+ */
+const credentialsCache = new Map();
+
+const clientCache = new Map();
+/**
+ * Creates an S3 client using the provided credentials.
+ */
+function createS3Client(credentials) {
+    const cacheKey = `${credentials.accessKeyId}-${credentials.region}`;
+    const cachedClient = clientCache.get(cacheKey);
+    if (cachedClient) {
+        return cachedClient;
+    }
+    const newClient = new S3Client({
+        credentials: {
+            accessKeyId: credentials.accessKeyId,
+            secretAccessKey: credentials.secretAccessKey,
+            sessionToken: credentials.sessionToken,
+        },
+        region: credentials.region,
+        useDualstackEndpoint: true,
+    });
+    clientCache.set(cacheKey, newClient);
+    return newClient;
+}
+
+/**
+ * Converts an S3 URI to a bucket and key
+ */
+function s3UriToParams(uri) {
+    const matches = /^s3:\/\/([^/]+)\/(.+)$/.exec(uri);
+    if (!matches) {
+        throw new Error(`Received invalid uri: '${uri}'`);
+    }
+    return {
+        Bucket: matches[1],
+        Key: matches[2],
+    };
+}
+
+/**
+ * Get a signed URL for a file in S3 given its S3 URI.
+ * Defaults to a 5 minute timeout.
+ */
+function getSignedUrl({ url, credentials, ...params }) {
+    var _a, _b;
+    const client = createS3Client(credentials);
+    const { Bucket, Key } = s3UriToParams(url);
+    const fileName = (_a = params.filename) !== null && _a !== void 0 ? _a : Key.split('/').pop();
+    const args = { Bucket, Key };
+    if (params === null || params === void 0 ? void 0 : params.download) {
+        args.ResponseContentDisposition = `attachment; filename="${fileName}"`;
+    }
+    if (params === null || params === void 0 ? void 0 : params.gzip) {
+        args.ResponseContentEncoding = 'gzip';
+    }
+    const command = new GetObjectCommand(args);
+    return getSignedUrl$1(client, command, { expiresIn: 60 * ((_b = params === null || params === void 0 ? void 0 : params.timeout) !== null && _b !== void 0 ? _b : 5) });
+}
+
+const resourcePrefix = 'project-';
+function getResourceName(projectId) {
+    return `${resourcePrefix}${projectId}`;
+}
+
+/**
+ * Get the S3 bucket name for a project.
+ * Will be deprecated in the future, use domain from manifest instead.
+ */
+function getProjectS3Bucket(projectId) {
+    return getResourceName(projectId);
+}
+
+/**
+ * Service for viewing files in Cirro
+ *  currently this only operates on files within a project
+ */
+class FileService {
+    constructor(fileCredsApi) {
+        this.fileCredsApi = fileCredsApi;
+    }
+    /**
+     * Get contents of a file
+     */
+    async getProjectFile(file) {
+        const url = await this.getSignedUrlFromProjectFile(file);
+        return fetch(url);
+    }
+    /**
+     * Get a signed URL for a file
+     */
+    async getSignedUrlFromProjectFile(file, params) {
+        const credentials = await this.getProjectAccessCredentials(file.fileAccessContext);
+        const _params = {
+            ...params,
+            filename: file.name,
+            url: file.url,
+            credentials,
+        };
+        return getSignedUrl(_params);
+    }
+    /**
+     * Get a signed URL for a file given a path
+     */
+    async getSignedUrlFromProjectPath(fileAccessContext, path, params) {
+        const credentials = await this.getProjectAccessCredentials(fileAccessContext);
+        const _params = {
+            ...params,
+            filename: path.split('/').pop(),
+            url: `s3://${getProjectS3Bucket(fileAccessContext.project.id)}/${path}`,
+            credentials,
+        };
+        return getSignedUrl(_params);
+    }
+    /**
+     * Get credentials for accessing a project file
+     */
+    async getProjectAccessCredentials(fileAccessContext) {
+        const accessType = fileAccessContext.fileAccessRequest.accessType;
+        // Special case for project download, since we can cache the credentials
+        if (accessType === ProjectAccessType.ProjectDownload || accessType === ProjectAccessType.SharedDatasetDownload) {
+            return this.getProjectReadCredentials(fileAccessContext);
+        }
+        return this.fileCredsApi.generateProjectFileAccessToken({ projectId: fileAccessContext.project.id, projectFileAccessRequest: fileAccessContext.fileAccessRequest });
+    }
+    async getProjectReadCredentials(fileAccessContext) {
+        const projectId = fileAccessContext.project.id;
+        // Append datasetId to cache key for shared dataset downloads since we need to generate a new token for each dataset
+        let cacheKey = projectId;
+        if (fileAccessContext.fileAccessRequest.accessType === ProjectAccessType.SharedDatasetDownload) {
+            cacheKey = `${projectId}-${fileAccessContext.fileAccessRequest.datasetId}`;
+        }
+        return credentialsMutex.dispatch(async () => {
+            const cachedCredentials = credentialsCache.get(cacheKey);
+            const expirationTime = cachedCredentials ? cachedCredentials === null || cachedCredentials === void 0 ? void 0 : cachedCredentials.expiration : null;
+            const fetchNewCredentials = !expirationTime || expirationTime < new Date();
+            if (fetchNewCredentials) {
+                const projectFileAccessRequest = fileAccessContext.fileAccessRequest;
+                const credentials = await this.fileCredsApi.generateProjectFileAccessToken({ projectId, projectFileAccessRequest });
+                credentialsCache.set(cacheKey, credentials);
+                return credentials;
+            }
+            return cachedCredentials;
+        });
+    }
+}
+
+/**
+ * Delete a file from S3 given its URL and credentials.
+ */
+async function deleteFile({ url, credentials }) {
+    const { Bucket, Key } = s3UriToParams(url);
+    const cmd = new DeleteObjectCommand({ Bucket, Key });
+    await createS3Client(credentials).send(cmd);
+}
+
+/**
+ * Upload a file to S3
+ */
+function uploadFile({ bucket, path, file, credentials, metadata }) {
+    const params = {
+        Bucket: bucket,
+        Key: path,
+        Body: file,
+        ContentType: file.type,
+        Metadata: metadata,
+    };
+    return new Upload({
+        client: createS3Client(credentials),
+        queueSize: 4,
+        params,
+    });
+}
+
+/**
+ * Helper class to encapsulate the file access for a project.
+ */
+class ProjectFileAccessContext {
+    constructor(project, dataset, fileAccessRequest) {
+        this.project = project;
+        this.dataset = dataset;
+        this.fileAccessRequest = fileAccessRequest;
+    }
+    static projectDownload(project) {
+        const request = { accessType: ProjectAccessType.ProjectDownload };
+        return new ProjectFileAccessContext(project, null, request);
+    }
+    static datasetDownload(project, dataset) {
+        const accessType = dataset.share ? ProjectAccessType.SharedDatasetDownload : ProjectAccessType.ProjectDownload;
+        const request = { accessType, datasetId: dataset.id };
+        return new ProjectFileAccessContext(project, dataset, request);
+    }
+}
+
+var FileSystemObjectType;
+(function (FileSystemObjectType) {
+    FileSystemObjectType["FILE"] = "file";
+    FileSystemObjectType["FOLDER"] = "folder";
+})(FileSystemObjectType || (FileSystemObjectType = {}));
+
+/**
+ * Calculate the total size of all files in a directory.
+ * @param files - An array of FileSystemObject representing the files in the directory.
+ * @return The total size of all files in bytes.
+ */
+function calculateTotalSize(files) {
+    let totalSize = 0;
+    for (const file of files) {
+        totalSize += file.size;
+    }
+    return totalSize;
+}
+
+/**
+ * Pretty prints a JSON object with the specified indentation level.
+ * @param obj JSON object to be pretty printed.
+ * @param indentLevel Number of spaces to use for indentation.
+ */
+function jsonPrettyPrint(obj, indentLevel = 2) {
+    return JSON.stringify(obj, null, indentLevel);
+}
+
+/**
+ * Format bytes as human-readable text.
+ * @param bytes Number of bytes.
+ * @param si True to use metric(SI) units, aka powers of 1000. False to use
+ * binary(IEC), aka powers of 1024.
+   * @param dp Number of decimal places to display.
+ *
+ * @return Formatted string.
+ */
+function bytesToString(bytes, si = false, dp = 1) {
+    const thresh = si ? 1000 : 1024;
+    if (Math.abs(bytes) < thresh) {
+        return `${bytes} B`;
+    }
+    const units = si
+        ? ['kB', 'MB', 'GB', 'TB', 'PB', 'EB', 'ZB', 'YB']
+        : ['KiB', 'MiB', 'GiB', 'TiB', 'PiB', 'EiB', 'ZiB', 'YiB'];
+    let u = -1;
+    const r = 10 ** dp;
+    do {
+        bytes /= thresh;
+        ++u;
+    } while (Math.round(Math.abs(bytes) * r) / r >= thresh
+        && u < units.length - 1);
+    return `${bytes.toFixed(dp)} ${units[u]}`;
+}
+
+/**
+ * Normalizes a date to UTC by adjusting for the timezone offset.
+ * Useful when you are working with dates that may not include time information.
+ * @param date
+ */
+function normalizeDate(date) {
+    if (!date)
+        throw new Error("Attempt to normalize undefined");
+    if (!(date instanceof Date))
+        date = new Date(date);
+    return new Date(date.getTime() - date.getTimezoneOffset() * -6e4);
+}
+
+/**
+ * Normalize a string by trimming it and returning null if it is empty.
+ * @param input The string to normalize.
+ */
+function normalizeString(input) {
+    if (!(input === null || input === void 0 ? void 0 : input.trim()))
+        return null;
+    return input.trim();
+}
+
+/**
+ * Removes the starting slash from a path.
+ * @param path Input path
+ */
+function removeStartingSlash(path) {
+    return (path === null || path === void 0 ? void 0 : path.startsWith('/')) ? path.substring(1) : path;
+}
+/**
+ * Removes the ending slash from a path.
+ * @param path Input path
+ */
+function removeEndingSlash(path) {
+    return (path === null || path === void 0 ? void 0 : path.endsWith('/')) ? path.slice(0, -1) : path;
+}
+
+const dateFormat = new Intl.DateTimeFormat('en-US', { month: '2-digit', day: '2-digit', year: '2-digit' });
+/**
+ * Converts a date string or Date object to MM/DD/YY date string.
+ * Ex., "2023-10-01" -> "10/01/23"
+ * @param date Input date string or Date object.
+ */
+function toDateFormat(date) {
+    if (!date)
+        return null;
+    const d = (typeof date === 'string') ? new Date(date) : date;
+    return dateFormat.format(d);
+}
+
+/**
+ * Converts a string to Title case.
+ * Ex., "hello world" -> "Hello world"
+ * @param value
+ */
+function toTitleCase(value) {
+    if (!value)
+        return null;
+    return value[0].toUpperCase() + value.slice(1).toLowerCase();
+}
+
+/**
+ * Converts a field name to a more human-readable format.
+ * Ex., "helloWorld" -> "Hello World"
+ * @param value The value to convert.
+ */
+function toFriendlyName(value) {
+    let _value = value.split(/(?=[A-Z])/).join(' ');
+    _value = _value.split('_').join(' ');
+    _value = _value.split('|').join(' ');
+    _value = _value.replace(/ +/g, ' ');
+    return toTitleCase(_value);
+}
+
+const money = new Intl.NumberFormat('en-US', {
+    style: 'currency',
+    currency: 'USD',
+});
+/**
+ * Converts a number or bigint to a formatted money string.
+ * Ex., 1234.56 -> $1,234.56
+ * @param value Input number or bigint value.
+ */
+function toMoney(value) {
+    return money.format(value);
+}
+
+/**
+ * Converts a string to PascalCase.
+ * Ex., "hello world" -> "HelloWorld"
+ * @param value The string to convert.
+ */
+function toPascalCase(value) {
+    return value.replace(/(\w)(\w*)/g, (g0, g1, g2) => g1.toUpperCase() + g2.toLowerCase());
+}
+
+class Assets extends Array {
+    // Total size of all files in human-readable format
+    get totalSize() {
+        if (!this._totalSize) {
+            this.calculateSize();
+        }
+        return this._totalSize;
+    }
+    get totalSizeBytes() {
+        if (!this._totalSizeBytes) {
+            this.calculateSize();
+        }
+        return this._totalSizeBytes;
+    }
+    calculateSize() {
+        this._totalSizeBytes = calculateTotalSize(this);
+        this._totalSize = bytesToString(this._totalSizeBytes);
+    }
+}
+
+class Folder {
+    constructor(url, name, path, domain) {
+        this.kind = 'Folder';
+        this.fileAccessContext = null;
+        this.size = 0;
+        this.type = FileSystemObjectType.FOLDER;
+        this.id = v4();
+        this.url = url;
+        this.name = name;
+        this.path = path;
+        this.domain = domain;
+    }
+}
+
+class File {
+    get type() {
+        return FileSystemObjectType.FILE;
+    }
+    get kind() {
+        return this.path.slice(this.
+            path.lastIndexOf('.') + 1);
+    }
+    constructor(domain, file, size, metadata, accessContext) {
+        this.id = v4();
+        this.url = `${domain}/${file}`;
+        this.size = size;
+        this.metadata = metadata;
+        this.fileAccessContext = accessContext;
+        const fileFolderIdx = file.lastIndexOf('/');
+        if (fileFolderIdx === -1) {
+            this.path = '';
+            this.name = file;
+        }
+        else {
+            this.path = file.substring(0, fileFolderIdx);
+            this.name = file.substring(fileFolderIdx + 1);
+        }
+    }
+}
+
+class ManifestParser {
+    constructor(manifest, accessContext) {
+        this.manifest = manifest;
+        this.accessContext = accessContext;
+    }
+    get files() {
+        var _a, _b;
+        return (_b = (_a = this.manifest) === null || _a === void 0 ? void 0 : _a.files) !== null && _b !== void 0 ? _b : [];
+    }
+    /**
+     * Generates asset objects from the manifest, optionally including folder entries.
+     */
+    generateAssets(generateFolders = false) {
+        var _a;
+        const domain = removeEndingSlash((_a = this.manifest) === null || _a === void 0 ? void 0 : _a.domain);
+        const assets = new Assets();
+        for (const file of this.files) {
+            assets.push(new File(domain, file.path, file.size, file.metadata, this.accessContext));
+        }
+        // Optionally add folder entries
+        if (generateFolders) {
+            assets.push(...this.generateFolderAssets(assets, domain));
+        }
+        return assets;
+    }
+    // Create folder entries, useful for visualizing folders as items in a file browser
+    generateFolderAssets(assets, domain) {
+        const folderSet = new Set();
+        // Collect all unique folder paths
+        for (const asset of assets) {
+            const parts = asset.path.split('/').filter(p => p.length > 0);
+            let currentPath = '';
+            for (const part of parts) {
+                currentPath = currentPath ? `${currentPath}/${part}` : part;
+                folderSet.add(currentPath);
+            }
+        }
+        // Create Folder objects from unique paths
+        return Array.from(folderSet)
+            .map(folderPath => {
+            const name = folderPath.substring(folderPath.lastIndexOf('/') + 1);
+            const parentPath = folderPath.includes('/') ? folderPath.substring(0, folderPath.lastIndexOf('/')) : '';
+            return new Folder(folderPath, name, parentPath, domain);
+        });
+    }
+}
+
+/**
+ * Returns the parent directory of a given file path.
+ */
+function getParentPath(path) {
+    var _a;
+    return (_a = path.split("/").slice(0, -1).join("/")) !== null && _a !== void 0 ? _a : "";
+}
+
+class ApiError extends Error {
+    constructor(message, errors) {
+        super(message);
+        this.errors = errors;
+    }
+}
+
+class PortalErrorHandler {
+    async post(context) {
+        const { response } = context;
+        if (response && (response.status >= 200 && response.status < 300)) {
+            return response;
+        }
+        // Handle Error
+        let errorMessage;
+        const errors = [];
+        try {
+            const err = await response.json();
+            console.warn(err);
+            if ('errorDetail' in err) {
+                errorMessage = err.errorDetail;
+                errors.push(err.errors.map((e) => e.message));
+            }
+            else {
+                errorMessage = err.message;
+            }
+        }
+        catch (ignore) {
+            errorMessage = "Unknown Error";
+        }
+        throw new ApiError(errorMessage, errors);
+    }
+}
+
+const generateApiConfig = ({ basePath = "/api", tokenGetter }) => {
+    return new Configuration({
+        basePath,
+        accessToken: tokenGetter,
+        middleware: [
+            new PortalErrorHandler()
+        ],
+    });
+};
+
+class CurrentUser {
+    static fromCognitoUser(idTokenPayload) {
+        var _a, _b;
+        return {
+            username: (_a = idTokenPayload["cognito:username"]) !== null && _a !== void 0 ? _a : idTokenPayload.username,
+            sub: idTokenPayload.sub,
+            authTime: new Date(idTokenPayload.auth_time * 1000),
+            groups: (_b = idTokenPayload["cognito:groups"]) !== null && _b !== void 0 ? _b : [],
+        };
+    }
+}
+
+class StaticTokenAuthProvider {
+    constructor(token) {
+        this.token = token;
+    }
+    configure(_ignore) {
+        console.log('StaticTokenAuthProvider loaded');
+    }
+    async getAccessToken() {
+        return this.token;
+    }
+    async getCurrentUser() {
+        const accessToken = await this.getAccessToken();
+        const parsedToken = JSON.parse(atob(accessToken.split('.')[1]));
+        return CurrentUser.fromCognitoUser(parsedToken);
+    }
+    forceRefresh() {
+        return Promise.resolve();
+    }
+}
+
+class DataService {
+    constructor({ tokenGetter, basePath = "/api" }) {
+        this.apiConfig = generateApiConfig({ basePath, tokenGetter });
+        this._auditApi = new AuditApi(this.apiConfig);
+        this._billingApi = new BillingApi(this.apiConfig);
+        this._computeEnvironmentApi = new ComputeEnvironmentApi(this.apiConfig);
+        this._datasetsApi = new DatasetsApi(this.apiConfig);
+        this._executionApi = new ExecutionApi(this.apiConfig);
+        this._fileApi = new FileApi(this.apiConfig);
+        this._governanceApi = new GovernanceApi(this.apiConfig);
+        this._metadataApi = new MetadataApi(this.apiConfig);
+        this._notebooksApi = new NotebooksApi(this.apiConfig);
+        this._processesApi = new ProcessesApi(this.apiConfig);
+        this._projectRequestsApi = new ProjectRequestsApi(this.apiConfig);
+        this._projectsApi = new ProjectsApi(this.apiConfig);
+        this._referencesApi = new ReferencesApi(this.apiConfig);
+        this._sharingApi = new SharingApi(this.apiConfig);
+        this._systemApi = new SystemApi(this.apiConfig);
+        this._toolsApi = new ToolsApi(this.apiConfig);
+        this._usersApi = new UsersApi(this.apiConfig);
+    }
+    get audit() {
+        return this._auditApi;
+    }
+    get billing() {
+        return this._billingApi;
+    }
+    get computeEnvironments() {
+        return this._computeEnvironmentApi;
+    }
+    get datasets() {
+        return this._datasetsApi;
+    }
+    get execution() {
+        return this._executionApi;
+    }
+    get file() {
+        return this._fileApi;
+    }
+    get governance() {
+        return this._governanceApi;
+    }
+    get metadata() {
+        return this._metadataApi;
+    }
+    get notebooks() {
+        return this._notebooksApi;
+    }
+    get processes() {
+        return this._processesApi;
+    }
+    get projectRequests() {
+        return this._projectRequestsApi;
+    }
+    get projects() {
+        return this._projectsApi;
+    }
+    get references() {
+        return this._referencesApi;
+    }
+    get sharing() {
+        return this._sharingApi;
+    }
+    get system() {
+        return this._systemApi;
+    }
+    get tools() {
+        return this._toolsApi;
+    }
+    get users() {
+        return this._usersApi;
+    }
+}
+
+/**
+ * Extracts a value from an object using the json path notation, i.e. $.test.id
+ * @param path JSON path to the value
+ * @param obj Object to extract the value from
+ */
+function extractFromObject(path, obj) {
+    const pathParts = path.slice(2).split('.');
+    return pathParts.reduce(function (o, k) {
+        return o && o[k];
+    }, obj);
+}
+
+/**
+ * Ignores dangling promise rejections.
+ * @param err The error to ignore.
+ */
+function handlePromiseError(err) {
+    console.warn(err);
+}
+
+/**
+ * Download a blob as a file with the specified file name.
+ */
+function downloadBlob(blob, fileName) {
+    const url = window.URL.createObjectURL(blob);
+    const a = document.createElement('a');
+    a.href = url;
+    a.download = fileName;
+    a.click();
+}
+/**
+ * Downloads the specified content as a file with the specified file name and type.
+ */
+function downloadContent(content, fileName, fileType = 'text/plain') {
+    const blob = new Blob([content], { type: fileType });
+    downloadBlob(blob, fileName);
+}
+
+export { ApiError, Assets, CurrentUser, DataService, FILE_BROWSER_EXTENSIONS, FILE_DSV_EXTENSIONS, FILE_EXTENSIONS_TO_OPEN, FILE_IMAGE_EXTENSIONS, FILE_OME_EXTENSIONS, FILE_PROTEIN_STRUCTURE_EXTENSIONS, FILE_TRACK_ALIGNMENTS, FILE_TRACK_ANNOTATION, FILE_TRACK_EXTENSIONS, FILE_TRACK_EXTENSIONS_NO_INDEX, FILE_TRACK_INDEX_EXTENSIONS, FILE_TRACK_SEG, FILE_TRACK_VARIANT, FILE_TRACK_WIG, FILE_TXT_EXTENSIONS, FILE_TXT_GENOMICS_EXTENSIONS, FILE_VITESSCE_EXTENSIONS, FileService, FileSystemObjectType, ManifestParser, ProjectFileAccessContext, StaticTokenAuthProvider, bytesToString, calculateTotalSize, createS3Client, credentialsCache, credentialsMutex, deleteFile, downloadBlob, downloadContent, extractFromObject, generateApiConfig, getParentPath, getProjectS3Bucket, getResourceName, getSignedUrl, handlePromiseError, jsonPrettyPrint, matchesExtension, normalizeDate, normalizeString, removeEndingSlash, removeStartingSlash, s3UriToParams, toDateFormat, toFriendlyName, toMoney, toPascalCase, toTitleCase, uploadFile };
+//# sourceMappingURL=index.esm.js.map