@noatgnu/cupcake-vanilla 1.0.0

package/fesm2022/noatgnu-cupcake-vanilla.mjs

@@ -0,0 +1,1179 @@
+import * as i0 from '@angular/core';
+import { Injectable, Component } from '@angular/core';
+import { BaseApiService } from '@cupcake/core';
+import { from, Observable } from 'rxjs';
+import { switchMap } from 'rxjs/operators';
+import jsSHA from 'jssha';
+
+var OntologyType;
+(function (OntologyType) {
+    OntologyType["SPECIES"] = "species";
+    OntologyType["TISSUE"] = "tissue";
+    OntologyType["HUMAN_DISEASE"] = "human_disease";
+    OntologyType["SUBCELLULAR_LOCATION"] = "subcellular_location";
+    OntologyType["UNIMOD"] = "unimod";
+    OntologyType["NCBI_TAXONOMY"] = "ncbi_taxonomy";
+    OntologyType["MONDO"] = "mondo";
+    OntologyType["UBERON"] = "uberon";
+    OntologyType["CHEBI"] = "chebi";
+    OntologyType["CELL_ONTOLOGY"] = "cell_ontology";
+    OntologyType["MS_UNIQUE_VOCABULARIES"] = "ms_unique_vocabularies";
+    OntologyType["PSI_MS"] = "psi_ms";
+})(OntologyType || (OntologyType = {}));
+const OntologyTypeLabels = {
+    [OntologyType.SPECIES]: 'Species',
+    [OntologyType.TISSUE]: 'Tissue',
+    [OntologyType.HUMAN_DISEASE]: 'Human Disease',
+    [OntologyType.SUBCELLULAR_LOCATION]: 'Subcellular Location',
+    [OntologyType.UNIMOD]: 'Unimod Modifications',
+    [OntologyType.NCBI_TAXONOMY]: 'NCBI Taxonomy',
+    [OntologyType.MONDO]: 'MONDO Disease',
+    [OntologyType.UBERON]: 'UBERON Anatomy',
+    [OntologyType.CHEBI]: 'ChEBI',
+    [OntologyType.CELL_ONTOLOGY]: 'Cell Ontology',
+    [OntologyType.MS_UNIQUE_VOCABULARIES]: 'MS Unique Vocabularies',
+    [OntologyType.PSI_MS]: 'PSI-MS Controlled Vocabulary'
+};
+var TemplatePermissionLevel;
+(function (TemplatePermissionLevel) {
+    TemplatePermissionLevel["READ"] = "read";
+    TemplatePermissionLevel["WRITE"] = "write";
+    TemplatePermissionLevel["ADMIN"] = "admin";
+})(TemplatePermissionLevel || (TemplatePermissionLevel = {}));
+const TemplatePermissionLabels = {
+    [TemplatePermissionLevel.READ]: 'Read Only',
+    [TemplatePermissionLevel.WRITE]: 'Read & Write',
+    [TemplatePermissionLevel.ADMIN]: 'Administrator'
+};
+
+function isUnimodFullData(suggestion) {
+    return suggestion &&
+        suggestion.ontology_type === 'unimod' &&
+        !!suggestion.full_data;
+}
+class OntologyUtils {
+    static getUnimodSpecifications(suggestion) {
+        if (!isUnimodFullData(suggestion))
+            return [];
+        return Object.entries(suggestion.full_data.specifications).map(([specNum, spec]) => ({
+            ...spec,
+            specNumber: specNum
+        }));
+    }
+    static getActiveUnimodSpecifications(suggestion) {
+        return this.getUnimodSpecifications(suggestion).filter(spec => !spec['hidden']);
+    }
+    static formatUnimodName(data) {
+        return `${data.name} (${data.accession})`;
+    }
+}
+
+// Helper constants
+const TASK_TYPE_LABELS = {
+    'EXPORT_EXCEL': 'Export Excel Template',
+    'EXPORT_SDRF': 'Export SDRF File',
+    'IMPORT_SDRF': 'Import SDRF File',
+    'IMPORT_EXCEL': 'Import Excel File',
+    'EXPORT_MULTIPLE_SDRF': 'Export Multiple SDRF Files',
+    'EXPORT_MULTIPLE_EXCEL': 'Export Multiple Excel Templates',
+    'VALIDATE_TABLE': 'Validate Metadata Table',
+};
+const TASK_STATUS_LABELS = {
+    'QUEUED': 'Queued',
+    'STARTED': 'In Progress',
+    'SUCCESS': 'Completed',
+    'FAILURE': 'Failed',
+    'CANCELLED': 'Cancelled',
+};
+const TASK_STATUS_COLORS = {
+    'QUEUED': 'secondary',
+    'STARTED': 'primary',
+    'SUCCESS': 'success',
+    'FAILURE': 'danger',
+    'CANCELLED': 'warning',
+};
+
+class MetadataTableService extends BaseApiService {
+    /**
+     * Get all metadata tables with optional filtering
+     */
+    getMetadataTables(params) {
+        const httpParams = this.buildHttpParams(params);
+        return this.get(`${this.apiUrl}/metadata-tables/`, { params: httpParams });
+    }
+    /**
+     * Get a single metadata table by ID
+     */
+    getMetadataTable(id) {
+        return this.get(`${this.apiUrl}/metadata-tables/${id}/`);
+    }
+    /**
+     * Create a new metadata table
+     */
+    createMetadataTable(table) {
+        return this.post(`${this.apiUrl}/metadata-tables/`, table);
+    }
+    /**
+     * Update an existing metadata table
+     */
+    updateMetadataTable(id, table) {
+        return this.put(`${this.apiUrl}/metadata-tables/${id}/`, table);
+    }
+    /**
+     * Partially update a metadata table
+     */
+    patchMetadataTable(id, table) {
+        return this.patch(`${this.apiUrl}/metadata-tables/${id}/`, table);
+    }
+    /**
+     * Delete a metadata table
+     */
+    deleteMetadataTable(id) {
+        return this.delete(`${this.apiUrl}/metadata-tables/${id}/`);
+    }
+    /**
+     * Add a column to the metadata table
+     */
+    addColumn(id, columnData, position) {
+        return this.post(`${this.apiUrl}/metadata-tables/${id}/add_column/`, {
+            column_data: columnData,
+            position
+        });
+    }
+    /**
+     * Add a column with automatic reordering
+     */
+    addColumnWithAutoReorder(id, request) {
+        return this.post(`${this.apiUrl}/metadata-tables/${id}/add_column_with_auto_reorder/`, request);
+    }
+    /**
+     * Remove a column from the metadata table
+     */
+    removeColumn(id, columnId) {
+        return this.post(`${this.apiUrl}/metadata-tables/${id}/remove_column/`, {
+            column_id: columnId
+        });
+    }
+    /**
+     * Reorder a column in the metadata table
+     */
+    reorderColumn(id, columnId, newPosition) {
+        return this.post(`${this.apiUrl}/metadata-tables/${id}/reorder_column/`, {
+            column_id: columnId,
+            new_position: newPosition
+        });
+    }
+    /**
+     * Normalize column positions
+     */
+    normalizeColumnPositions(id) {
+        return this.post(`${this.apiUrl}/metadata-tables/${id}/normalize_column_positions/`, {});
+    }
+    /**
+     * Get all tables (admin only)
+     */
+    getAdminAllTables() {
+        return this.get(`${this.apiUrl}/metadata-tables/admin_all_tables/`);
+    }
+    /**
+     * Search metadata tables
+     */
+    searchMetadataTables(query) {
+        return this.getMetadataTables({ search: query });
+    }
+    /**
+     * Get metadata tables by owner
+     */
+    getMetadataTablesByOwner(ownerId) {
+        return this.getMetadataTables({ ownerId: ownerId });
+    }
+    /**
+     * Get shared metadata tables
+     */
+    getSharedMetadataTables() {
+        return this.getMetadataTables({ showShared: true });
+    }
+    /**
+     * Combine columns column-wise
+     */
+    combineColumnwise(request) {
+        return this.post(`${this.apiUrl}/metadata-tables/combine_columnwise/`, request);
+    }
+    /**
+     * Combine columns row-wise
+     */
+    combineRowwise(request) {
+        return this.post(`${this.apiUrl}/metadata-tables/combine_rowwise/`, request);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.1.7", ngImport: i0, type: MetadataTableService, deps: null, target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.1.7", ngImport: i0, type: MetadataTableService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.7", ngImport: i0, type: MetadataTableService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+
+class MetadataColumnService extends BaseApiService {
+    /**
+     * Get all metadata columns with optional filtering
+     */
+    getMetadataColumns(params) {
+        const httpParams = this.buildHttpParams(params);
+        return this.get(`${this.apiUrl}/metadata-columns/`, { params: httpParams });
+    }
+    /**
+     * Get a single metadata column by ID
+     */
+    getMetadataColumn(id) {
+        return this.get(`${this.apiUrl}/metadata-columns/${id}/`);
+    }
+    /**
+     * Create a new metadata column
+     */
+    createMetadataColumn(column) {
+        return this.post(`${this.apiUrl}/metadata-columns/`, column);
+    }
+    /**
+     * Update an existing metadata column
+     */
+    updateMetadataColumn(id, column) {
+        return this.put(`${this.apiUrl}/metadata-columns/${id}/`, column);
+    }
+    /**
+     * Partially update a metadata column
+     */
+    patchMetadataColumn(id, column) {
+        return this.patch(`${this.apiUrl}/metadata-columns/${id}/`, column);
+    }
+    /**
+     * Delete a metadata column
+     */
+    deleteMetadataColumn(id) {
+        return this.delete(`${this.apiUrl}/metadata-columns/${id}/`);
+    }
+    /**
+     * Bulk create metadata columns
+     */
+    bulkCreate(request) {
+        return this.post(`${this.apiUrl}/metadata-columns/bulk_create/`, request);
+    }
+    /**
+     * Validate SDRF data
+     */
+    validateSdrfData(request) {
+        return this.post(`${this.apiUrl}/metadata-columns/validate_sdrf_data/`, request);
+    }
+    /**
+     * Get ontology suggestions for a column
+     */
+    getOntologySuggestions(params) {
+        const httpParams = this.buildHttpParams(params);
+        return this.get(`${this.apiUrl}/metadata-columns/ontology_suggestions/`, { params: httpParams });
+    }
+    /**
+     * Validate value against column's ontology
+     */
+    validateValue(id, request) {
+        return this.post(`${this.apiUrl}/metadata-columns/${id}/validate_value/`, request);
+    }
+    /**
+     * Update column value with automatic modifier calculation
+     */
+    updateColumnValue(id, request) {
+        return this.post(`${this.apiUrl}/metadata-columns/${id}/update_column_value/`, request);
+    }
+    /**
+     * Apply automatic ontology mapping to a column
+     */
+    applyOntologyMapping(id) {
+        return this.post(`${this.apiUrl}/metadata-columns/${id}/apply_ontology_mapping/`, {});
+    }
+    /**
+     * Detect ontology type for given column name and type
+     */
+    detectOntologyType(params) {
+        const httpParams = this.buildHttpParams(params);
+        return this.get(`${this.apiUrl}/metadata-columns/detect_ontology_type/`, { params: httpParams });
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.1.7", ngImport: i0, type: MetadataColumnService, deps: null, target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.1.7", ngImport: i0, type: MetadataColumnService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.7", ngImport: i0, type: MetadataColumnService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+
+class SamplePoolService extends BaseApiService {
+    /**
+     * Get all sample pools with optional filtering
+     */
+    getSamplePools(params) {
+        const httpParams = this.buildHttpParams(params);
+        return this.get(`${this.apiUrl}/sample-pools/`, { params: httpParams });
+    }
+    /**
+     * Get a single sample pool by ID
+     */
+    getSamplePool(id) {
+        return this.get(`${this.apiUrl}/sample-pools/${id}/`);
+    }
+    /**
+     * Create a new sample pool
+     */
+    createSamplePool(pool) {
+        return this.post(`${this.apiUrl}/sample-pools/`, pool);
+    }
+    /**
+     * Update an existing sample pool
+     */
+    updateSamplePool(id, pool) {
+        return this.put(`${this.apiUrl}/sample-pools/${id}/`, pool);
+    }
+    /**
+     * Partially update a sample pool
+     */
+    patchSamplePool(id, pool) {
+        return this.patch(`${this.apiUrl}/sample-pools/${id}/`, pool);
+    }
+    /**
+     * Delete a sample pool
+     */
+    deleteSamplePool(id) {
+        return this.delete(`${this.apiUrl}/sample-pools/${id}/`);
+    }
+    /**
+     * Get metadata columns associated with this pool
+     */
+    getMetadataColumns(id) {
+        return this.get(`${this.apiUrl}/sample-pools/${id}/metadata_columns/`);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.1.7", ngImport: i0, type: SamplePoolService, deps: null, target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.1.7", ngImport: i0, type: SamplePoolService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.7", ngImport: i0, type: SamplePoolService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+
+class MetadataTableTemplateService extends BaseApiService {
+    /**
+     * Get all metadata table templates with optional filtering
+     */
+    getMetadataTableTemplates(params) {
+        const httpParams = this.buildHttpParams(params);
+        return this.get(`${this.apiUrl}/metadata-table-templates/`, { params: httpParams });
+    }
+    /**
+     * Get a single metadata table template by ID
+     */
+    getMetadataTableTemplate(id) {
+        return this.get(`${this.apiUrl}/metadata-table-templates/${id}/`);
+    }
+    /**
+     * Create a new metadata table template
+     */
+    createMetadataTableTemplate(template) {
+        return this.post(`${this.apiUrl}/metadata-table-templates/`, template);
+    }
+    /**
+     * Update an existing metadata table template
+     */
+    updateMetadataTableTemplate(id, template) {
+        return this.put(`${this.apiUrl}/metadata-table-templates/${id}/`, template);
+    }
+    /**
+     * Partially update a metadata table template
+     */
+    patchMetadataTableTemplate(id, template) {
+        return this.patch(`${this.apiUrl}/metadata-table-templates/${id}/`, template);
+    }
+    /**
+     * Delete a metadata table template
+     */
+    deleteMetadataTableTemplate(id) {
+        return this.delete(`${this.apiUrl}/metadata-table-templates/${id}/`);
+    }
+    /**
+     * Add a column to the template
+     */
+    addColumn(id, request) {
+        return this.post(`${this.apiUrl}/metadata-table-templates/${id}/add_column/`, request);
+    }
+    /**
+     * Remove a column from the template
+     */
+    removeColumn(id, request) {
+        return this.post(`${this.apiUrl}/metadata-table-templates/${id}/remove_column/`, request);
+    }
+    /**
+     * Reorder a column within the template
+     */
+    reorderColumn(id, request) {
+        return this.post(`${this.apiUrl}/metadata-table-templates/${id}/reorder_column/`, request);
+    }
+    /**
+     * Add a column with automatic reordering
+     */
+    addColumnWithAutoReorder(id, request) {
+        return this.post(`${this.apiUrl}/metadata-table-templates/${id}/add_column_with_auto_reorder/`, request);
+    }
+    /**
+     * Duplicate a column within the template
+     */
+    duplicateColumn(id, request) {
+        return this.post(`${this.apiUrl}/metadata-table-templates/${id}/duplicate_column/`, request);
+    }
+    /**
+     * Normalize column positions
+     */
+    normalizeColumnPositions(id) {
+        return this.post(`${this.apiUrl}/metadata-table-templates/${id}/normalize_column_positions/`, {});
+    }
+    /**
+     * Apply this template to a metadata table
+     */
+    applyToMetadataTable(id, request) {
+        return this.post(`${this.apiUrl}/metadata-table-templates/${id}/apply_to_metadata_table/`, request);
+    }
+    /**
+     * Update field mask for template
+     */
+    updateFieldMask(id, request) {
+        return this.post(`${this.apiUrl}/metadata-table-templates/${id}/update_field_mask/`, request);
+    }
+    /**
+     * Get field mask for template
+     */
+    getFieldMask(id) {
+        return this.get(`${this.apiUrl}/metadata-table-templates/${id}/get_field_mask/`);
+    }
+    /**
+     * Get columns with field masks
+     */
+    getColumnsWithFieldMasks(id) {
+        return this.get(`${this.apiUrl}/metadata-table-templates/${id}/get_columns_with_field_masks/`);
+    }
+    /**
+     * Get available schemas for creating templates
+     */
+    getAvailableSchemas() {
+        return this.get(`${this.apiUrl}/metadata-table-templates/available_schemas/`);
+    }
+    /**
+     * Create a new template from schema definitions
+     */
+    createFromSchema(request) {
+        return this.post(`${this.apiUrl}/metadata-table-templates/create_from_schema/`, request);
+    }
+    /**
+     * Create a new metadata table from an existing template
+     */
+    createTableFromTemplate(request) {
+        return this.post(`${this.apiUrl}/metadata-table-templates/create_table_from_template/`, request);
+    }
+    /**
+     * Create a new metadata table directly from schema definitions
+     */
+    createTableFromSchemas(request) {
+        return this.post(`${this.apiUrl}/metadata-table-templates/create_table_from_schemas/`, request);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.1.7", ngImport: i0, type: MetadataTableTemplateService, deps: null, target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.1.7", ngImport: i0, type: MetadataTableTemplateService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.7", ngImport: i0, type: MetadataTableTemplateService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+
+class FavouriteMetadataOptionService extends BaseApiService {
+    /**
+     * Get all favourite metadata options with optional filtering
+     */
+    getFavouriteMetadataOptions(params) {
+        const httpParams = this.buildHttpParams(params);
+        return this.get(`${this.apiUrl}/favourite-metadata-options/`, { params: httpParams });
+    }
+    /**
+     * Get a single favourite metadata option by ID
+     */
+    getFavouriteMetadataOption(id) {
+        return this.get(`${this.apiUrl}/favourite-metadata-options/${id}/`);
+    }
+    /**
+     * Create a new favourite metadata option
+     */
+    createFavouriteMetadataOption(option) {
+        return this.post(`${this.apiUrl}/favourite-metadata-options/`, option);
+    }
+    /**
+     * Update an existing favourite metadata option
+     */
+    updateFavouriteMetadataOption(id, option) {
+        return this.put(`${this.apiUrl}/favourite-metadata-options/${id}/`, option);
+    }
+    /**
+     * Partially update a favourite metadata option
+     */
+    patchFavouriteMetadataOption(id, option) {
+        return this.patch(`${this.apiUrl}/favourite-metadata-options/${id}/`, option);
+    }
+    /**
+     * Delete a favourite metadata option
+     */
+    deleteFavouriteMetadataOption(id) {
+        return this.delete(`${this.apiUrl}/favourite-metadata-options/${id}/`);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.1.7", ngImport: i0, type: FavouriteMetadataOptionService, deps: null, target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.1.7", ngImport: i0, type: FavouriteMetadataOptionService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.7", ngImport: i0, type: FavouriteMetadataOptionService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+
+class MetadataColumnTemplateService extends BaseApiService {
+    /**
+     * Get all metadata column templates with optional filtering
+     */
+    getMetadataColumnTemplates(params) {
+        const httpParams = this.buildHttpParams(params);
+        return this.get(`${this.apiUrl}/metadata-column-templates/`, { params: httpParams });
+    }
+    /**
+     * Get a single metadata column template by ID
+     */
+    getMetadataColumnTemplate(id) {
+        return this.get(`${this.apiUrl}/metadata-column-templates/${id}/`);
+    }
+    /**
+     * Create a new metadata column template
+     */
+    createMetadataColumnTemplate(template) {
+        return this.post(`${this.apiUrl}/metadata-column-templates/`, template);
+    }
+    /**
+     * Update an existing metadata column template
+     */
+    updateMetadataColumnTemplate(id, template) {
+        return this.put(`${this.apiUrl}/metadata-column-templates/${id}/`, template);
+    }
+    /**
+     * Partially update a metadata column template
+     */
+    patchMetadataColumnTemplate(id, template) {
+        return this.patch(`${this.apiUrl}/metadata-column-templates/${id}/`, template);
+    }
+    /**
+     * Delete a metadata column template
+     */
+    deleteMetadataColumnTemplate(id) {
+        return this.delete(`${this.apiUrl}/metadata-column-templates/${id}/`);
+    }
+    /**
+     * Create a MetadataColumn from this template
+     */
+    createMetadataColumn(id, request) {
+        return this.post(`${this.apiUrl}/metadata-column-templates/${id}/create_metadata_column/`, request);
+    }
+    /**
+     * Share this template with another user
+     */
+    shareTemplate(id, request) {
+        return this.post(`${this.apiUrl}/metadata-column-templates/${id}/share_template/`, request);
+    }
+    /**
+     * Remove template sharing for a user
+     */
+    unshareTemplate(id, request) {
+        return this.delete(`${this.apiUrl}/metadata-column-templates/${id}/unshare_template/`, { body: request });
+    }
+    /**
+     * Get templates created by the current user
+     */
+    getMyTemplates() {
+        return this.get(`${this.apiUrl}/metadata-column-templates/my_templates/`);
+    }
+    /**
+     * Get most popular public templates
+     */
+    getPopularTemplates() {
+        return this.get(`${this.apiUrl}/metadata-column-templates/popular_templates/`);
+    }
+    /**
+     * Get ontology suggestions for this column template
+     */
+    getOntologySuggestions(params) {
+        const httpParams = this.buildHttpParams({
+            template_id: params?.templateId,
+            search: params?.search,
+            limit: params?.limit,
+            search_type: params?.searchType
+        });
+        return this.get(`${this.apiUrl}/metadata-column-templates/ontology_suggestions/`, { params: httpParams });
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.1.7", ngImport: i0, type: MetadataColumnTemplateService, deps: null, target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.1.7", ngImport: i0, type: MetadataColumnTemplateService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.7", ngImport: i0, type: MetadataColumnTemplateService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+
+class MetadataColumnTemplateShareService extends BaseApiService {
+    /**
+     * Get all template shares with optional filtering
+     */
+    getMetadataColumnTemplateShares(params) {
+        const httpParams = this.buildHttpParams(params);
+        return this.get(`${this.apiUrl}/metadata-column-template-shares/`, { params: httpParams });
+    }
+    /**
+     * Get a single template share by ID
+     */
+    getMetadataColumnTemplateShare(id) {
+        return this.get(`${this.apiUrl}/metadata-column-template-shares/${id}/`);
+    }
+    /**
+     * Create a new template share
+     */
+    createMetadataColumnTemplateShare(share) {
+        return this.post(`${this.apiUrl}/metadata-column-template-shares/`, share);
+    }
+    /**
+     * Update an existing template share
+     */
+    updateMetadataColumnTemplateShare(id, share) {
+        return this.put(`${this.apiUrl}/metadata-column-template-shares/${id}/`, share);
+    }
+    /**
+     * Delete a template share
+     */
+    deleteMetadataColumnTemplateShare(id) {
+        return this.delete(`${this.apiUrl}/metadata-column-template-shares/${id}/`);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.1.7", ngImport: i0, type: MetadataColumnTemplateShareService, deps: null, target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.1.7", ngImport: i0, type: MetadataColumnTemplateShareService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.7", ngImport: i0, type: MetadataColumnTemplateShareService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+
+class MetadataManagementService extends BaseApiService {
+    /**
+     * Export metadata as Excel template (matching original CUPCAKE)
+     */
+    exportExcelTemplate(request) {
+        return this.post(`${this.apiUrl}/metadata-management/export_excel_template/`, request, { responseType: 'blob' });
+    }
+    /**
+     * Import metadata from SDRF file with intelligent column matching and schema organization
+     */
+    importSdrfFile(file, additionalData) {
+        const formData = new FormData();
+        formData.append('file', file);
+        if (additionalData) {
+            Object.keys(additionalData).forEach(key => {
+                formData.append(key, additionalData[key]);
+            });
+        }
+        return this.post(`${this.apiUrl}/metadata-management/import_sdrf_file/`, formData);
+    }
+    /**
+     * Import metadata from Excel file (matching original CUPCAKE)
+     */
+    importExcelFile(file, additionalData) {
+        const formData = new FormData();
+        formData.append('file', file);
+        if (additionalData) {
+            Object.keys(additionalData).forEach(key => {
+                formData.append(key, additionalData[key]);
+            });
+        }
+        return this.post(`${this.apiUrl}/metadata-management/import_excel_file/`, formData);
+    }
+    /**
+     * Collect metadata from metadata table
+     */
+    collectMetadata(params) {
+        const httpParams = this.buildHttpParams(params);
+        return this.get(`${this.apiUrl}/metadata-management/collect_metadata/`, { params: httpParams });
+    }
+    /**
+     * Export metadata as SDRF file (matching original CUPCAKE)
+     */
+    exportSdrfFile(request) {
+        return this.post(`${this.apiUrl}/metadata-management/export_sdrf_file/`, request, { responseType: 'blob' });
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.1.7", ngImport: i0, type: MetadataManagementService, deps: null, target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.1.7", ngImport: i0, type: MetadataManagementService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.7", ngImport: i0, type: MetadataManagementService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+
+class OntologySearchService extends BaseApiService {
+    /**
+     * Get ontology suggestions across all sources for SDRF validation
+     */
+    suggest(params) {
+        const httpParams = this.buildHttpParams(params);
+        return this.get(`${this.apiUrl}/ontology-search/suggest/`, { params: httpParams });
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.1.7", ngImport: i0, type: OntologySearchService, deps: null, target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.1.7", ngImport: i0, type: OntologySearchService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.7", ngImport: i0, type: OntologySearchService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+
+class SchemaService extends BaseApiService {
+    /**
+     * Get all schemas with optional filtering
+     */
+    getSchemas(params) {
+        const httpParams = this.buildHttpParams(params);
+        return this.get(`${this.apiUrl}/schemas/`, { params: httpParams });
+    }
+    /**
+     * Get a single schema by ID
+     */
+    getSchema(id) {
+        return this.get(`${this.apiUrl}/schemas/${id}/`);
+    }
+    /**
+     * Get list of available schemas for creating templates
+     */
+    getAvailableSchemas() {
+        return this.get(`${this.apiUrl}/schemas/available/`);
+    }
+    /**
+     * Sync builtin schemas from sdrf-pipelines package (admin only)
+     */
+    syncBuiltin() {
+        return this.post(`${this.apiUrl}/schemas/sync_builtin/`, {});
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.1.7", ngImport: i0, type: SchemaService, deps: null, target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.1.7", ngImport: i0, type: SchemaService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.7", ngImport: i0, type: SchemaService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+
+class SDRFDefaultsService extends BaseApiService {
+    /**
+     * Get all available SDRF columns with their default values
+     */
+    getColumns() {
+        return this.get(`${this.apiUrl}/sdrf-defaults/columns/`);
+    }
+    /**
+     * Get default values for a specific column
+     */
+    getColumnValues(params) {
+        const httpParams = this.buildHttpParams(params);
+        return this.get(`${this.apiUrl}/sdrf-defaults/column_values/`, { params: httpParams });
+    }
+    /**
+     * Search for columns containing the query string
+     */
+    searchColumns(params) {
+        const httpParams = this.buildHttpParams(params);
+        return this.get(`${this.apiUrl}/sdrf-defaults/search/`, { params: httpParams });
+    }
+    /**
+     * Get options for structured fields (key-value pairs)
+     */
+    getStructuredOptions(params) {
+        const httpParams = this.buildHttpParams(params);
+        return this.get(`${this.apiUrl}/sdrf-defaults/structured_options/`, { params: httpParams });
+    }
+    /**
+     * Get all label options (TMT, SILAC, label-free)
+     */
+    getLabels() {
+        return this.get(`${this.apiUrl}/sdrf-defaults/labels/`);
+    }
+    /**
+     * Get protein modification options (fixed and variable)
+     */
+    getModifications() {
+        return this.get(`${this.apiUrl}/sdrf-defaults/modifications/`);
+    }
+    /**
+     * Get list of common instrument models
+     */
+    getInstruments() {
+        return this.get(`${this.apiUrl}/sdrf-defaults/instruments/`);
+    }
+    /**
+     * Get cleavage agent options
+     */
+    getCleavageAgents() {
+        return this.get(`${this.apiUrl}/sdrf-defaults/cleavage_agents/`);
+    }
+    /**
+     * Get all compound fields that require special handling
+     */
+    getCompoundFields() {
+        return this.get(`${this.apiUrl}/sdrf-defaults/compound_fields/`);
+    }
+    /**
+     * Get schema for a specific compound field
+     */
+    getCompoundSchema(params) {
+        const httpParams = this.buildHttpParams(params);
+        return this.get(`${this.apiUrl}/sdrf-defaults/compound_schema/`, { params: httpParams });
+    }
+    /**
+     * Validate a compound field value against its schema
+     */
+    validateCompound(request) {
+        return this.post(`${this.apiUrl}/sdrf-defaults/validate_compound/`, request);
+    }
+    /**
+     * Get column name suggestions based on partial input
+     */
+    getSuggestions(params) {
+        const httpParams = this.buildHttpParams(params);
+        return this.get(`${this.apiUrl}/sdrf-defaults/suggestions/`, { params: httpParams });
+    }
+    /**
+     * Get quick access to commonly used value categories
+     */
+    getQuickValues() {
+        return this.get(`${this.apiUrl}/sdrf-defaults/quick_values/`);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.1.7", ngImport: i0, type: SDRFDefaultsService, deps: null, target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.1.7", ngImport: i0, type: SDRFDefaultsService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.7", ngImport: i0, type: SDRFDefaultsService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+
+class AsyncTaskService extends BaseApiService {
+    /**
+     * Get all async tasks for the current user with optional filtering
+     */
+    getAsyncTasks(params) {
+        const httpParams = this.buildHttpParams(params);
+        return this.get(`${this.apiUrl}/async-tasks/`, { params: httpParams });
+    }
+    /**
+     * Get a specific async task by ID
+     */
+    getAsyncTask(id) {
+        return this.get(`${this.apiUrl}/async-tasks/${id}/`);
+    }
+    /**
+     * Cancel a queued or running task
+     */
+    cancelTask(id) {
+        return this.delete(`${this.apiUrl}/async-tasks/${id}/cancel/`);
+    }
+    /**
+     * Generate a signed download URL for task result file
+     */
+    getDownloadUrl(id) {
+        return this.get(`${this.apiUrl}/async-tasks/${id}/download_url/`);
+    }
+    /**
+     * Direct download endpoint (returns blob for file download)
+     */
+    downloadTaskFile(id, token) {
+        const httpParams = this.buildHttpParams({ token });
+        return this.get(`${this.apiUrl}/async-tasks/${id}/download/`, { params: httpParams, responseType: 'blob' });
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.1.7", ngImport: i0, type: AsyncTaskService, deps: null, target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.1.7", ngImport: i0, type: AsyncTaskService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.7", ngImport: i0, type: AsyncTaskService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+
+class AsyncExportService extends BaseApiService {
+    excelTemplate(request) {
+        return this.post(`${this.apiUrl}/async-export/excel_template/`, request);
+    }
+    sdrfFile(request) {
+        return this.post(`${this.apiUrl}/async-export/sdrf_file/`, request);
+    }
+    multipleSdrfFiles(request) {
+        return this.post(`${this.apiUrl}/async-export/multiple_sdrf_files/`, request);
+    }
+    multipleExcelTemplates(request) {
+        return this.post(`${this.apiUrl}/async-export/multiple_excel_templates/`, request);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.1.7", ngImport: i0, type: AsyncExportService, deps: null, target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.1.7", ngImport: i0, type: AsyncExportService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.7", ngImport: i0, type: AsyncExportService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+
+class AsyncImportService extends BaseApiService {
+    /**
+     * Calculate SHA256 hash of a file
+     */
+    async calculateSHA256(file) {
+        const buffer = await file.arrayBuffer();
+        const hashBuffer = await crypto.subtle.digest('SHA-256', buffer);
+        const hashArray = Array.from(new Uint8Array(hashBuffer));
+        const hashHex = hashArray.map(b => b.toString(16).padStart(2, '0')).join('');
+        return hashHex;
+    }
+    sdrfFile(request) {
+        return from(this.calculateSHA256(request.file)).pipe(switchMap(sha256Hash => {
+            const formData = new FormData();
+            formData.append('metadata_table_id', request.metadataTableId.toString());
+            formData.append('file', request.file);
+            formData.append('sha256', sha256Hash);
+            if (request.replaceExisting !== undefined) {
+                formData.append('replace_existing', request.replaceExisting.toString());
+            }
+            if (request.validateOntologies !== undefined) {
+                formData.append('validate_ontologies', request.validateOntologies.toString());
+            }
+            return this.post(`${this.apiUrl}/async-import/sdrf_file/`, formData);
+        }));
+    }
+    excelFile(request) {
+        const formData = new FormData();
+        formData.append('metadata_table_id', request.metadataTableId.toString());
+        formData.append('file', request.file);
+        if (request.replaceExisting !== undefined) {
+            formData.append('replace_existing', request.replaceExisting.toString());
+        }
+        if (request.validateOntologies !== undefined) {
+            formData.append('validate_ontologies', request.validateOntologies.toString());
+        }
+        return this.post(`${this.apiUrl}/async-import/excel_file/`, formData);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.1.7", ngImport: i0, type: AsyncImportService, deps: null, target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.1.7", ngImport: i0, type: AsyncImportService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.7", ngImport: i0, type: AsyncImportService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+
+class AsyncValidationService extends BaseApiService {
+    metadataTable(request) {
+        return this.post(`${this.apiUrl}/async-validation/metadata_table/`, request);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.1.7", ngImport: i0, type: AsyncValidationService, deps: null, target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.1.7", ngImport: i0, type: AsyncValidationService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.7", ngImport: i0, type: AsyncValidationService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+
+class ChunkedUploadService extends BaseApiService {
+    /**
+     * Initialize or continue a chunked upload
+     */
+    uploadChunk(request, uploadId, offset, totalSize) {
+        const formData = new FormData();
+        formData.append('file', request.file);
+        if (request.filename) {
+            formData.append('filename', request.filename);
+        }
+        if (request.uploadSessionId) {
+            formData.append('upload_session_id', request.uploadSessionId);
+        }
+        if (request.metadataTableId) {
+            formData.append('metadata_table_id', request.metadataTableId.toString());
+        }
+        if (request.createPools !== undefined) {
+            formData.append('create_pools', request.createPools.toString());
+        }
+        if (request.replaceExisting !== undefined) {
+            formData.append('replace_existing', request.replaceExisting.toString());
+        }
+        const url = uploadId
+            ? `${this.apiUrl}/chunked-upload/${uploadId}/`
+            : `${this.apiUrl}/chunked-upload/`;
+        // Add Content-Range header for chunked uploads
+        const headers = {};
+        if (offset !== undefined && totalSize !== undefined) {
+            const chunkEnd = offset + request.file.size - 1;
+            headers['Content-Range'] = `bytes ${offset}-${chunkEnd}/${totalSize}`;
+        }
+        // Use POST for first chunk, PUT for subsequent chunks
+        if (uploadId) {
+            return this.put(url, formData, { headers });
+        }
+        else {
+            return this.post(url, formData, { headers });
+        }
+    }
+    /**
+     * Get chunked upload status
+     */
+    getUploadStatus(uploadId) {
+        return this.get(`${this.apiUrl}/chunked-upload/${uploadId}/`);
+    }
+    /**
+     * Complete the chunked upload and process the file
+     */
+    completeUpload(uploadId, request) {
+        const formData = new FormData();
+        if (request?.sha256) {
+            formData.append('sha256', request.sha256);
+        }
+        if (request?.metadataTableId) {
+            formData.append('metadata_table_id', request.metadataTableId.toString());
+        }
+        if (request?.createPools !== undefined) {
+            formData.append('create_pools', request.createPools.toString());
+        }
+        if (request?.replaceExisting !== undefined) {
+            formData.append('replace_existing', request.replaceExisting.toString());
+        }
+        return this.post(`${this.apiUrl}/chunked-upload/${uploadId}/`, formData);
+    }
+    /**
+     * Delete/cancel a chunked upload
+     */
+    cancelUpload(uploadId) {
+        return this.delete(`${this.apiUrl}/chunked-upload/${uploadId}/`);
+    }
+    /**
+     * Helper method to upload a file in chunks with progress tracking
+     */
+    uploadFileInChunks(file, chunkSize = 1024 * 1024, // 1MB chunks by default
+    options) {
+        return new Observable(subscriber => {
+            let uploadId;
+            let offset = 0;
+            const totalSize = file.size;
+            const sha256 = new jsSHA('SHA-256', 'ARRAYBUFFER');
+            const uploadNextChunk = () => {
+                if (offset >= totalSize) {
+                    // Upload complete, finalize with calculated hash
+                    if (uploadId) {
+                        const calculatedHash = sha256.getHash('HEX');
+                        this.completeUpload(uploadId, {
+                            sha256: calculatedHash,
+                            metadataTableId: options?.metadataTableId,
+                            createPools: options?.createPools,
+                            replaceExisting: options?.replaceExisting
+                        }).subscribe({
+                            next: (result) => {
+                                subscriber.next(result);
+                                subscriber.complete();
+                            },
+                            error: (error) => subscriber.error(error)
+                        });
+                    }
+                    else {
+                        subscriber.error(new Error('Upload failed: No upload ID'));
+                    }
+                    return;
+                }
+                const end = Math.min(offset + chunkSize, totalSize);
+                const chunk = file.slice(offset, end);
+                const chunkFile = new File([chunk], file.name, { type: file.type });
+                // Add chunk to hash calculation
+                chunk.arrayBuffer().then(arrayBuffer => {
+                    sha256.update(arrayBuffer);
+                    this.uploadChunk({
+                        file: chunkFile,
+                        filename: file.name,
+                        uploadSessionId: options?.uploadSessionId,
+                        metadataTableId: options?.metadataTableId,
+                        createPools: options?.createPools,
+                        replaceExisting: options?.replaceExisting
+                    }, uploadId, offset, totalSize).subscribe({
+                        next: (response) => {
+                            uploadId = response.id;
+                            offset = response.offset;
+                            // Report progress
+                            const progress = (offset / totalSize) * 100;
+                            if (options?.onProgress) {
+                                options.onProgress(progress);
+                            }
+                            // Upload next chunk
+                            uploadNextChunk();
+                        },
+                        error: (error) => subscriber.error(error)
+                    });
+                }).catch(error => subscriber.error(error));
+            };
+            uploadNextChunk();
+        });
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.1.7", ngImport: i0, type: ChunkedUploadService, deps: null, target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.1.7", ngImport: i0, type: ChunkedUploadService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.7", ngImport: i0, type: ChunkedUploadService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+
+class CupcakeVanilla {
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.1.7", ngImport: i0, type: CupcakeVanilla, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "20.1.7", type: CupcakeVanilla, isStandalone: true, selector: "ccv-cupcake-vanilla", ngImport: i0, template: `
+    <p>
+      cupcake-vanilla works!
+    </p>
+  `, isInline: true, styles: [""] });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.1.7", ngImport: i0, type: CupcakeVanilla, decorators: [{
+            type: Component,
+            args: [{ selector: 'ccv-cupcake-vanilla', imports: [], template: `
+    <p>
+      cupcake-vanilla works!
+    </p>
+  ` }]
+        }] });
+
+/*
+ * Public API Surface of cupcake-vanilla
+ */
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { AsyncExportService, AsyncImportService, AsyncTaskService, AsyncValidationService, ChunkedUploadService, CupcakeVanilla, FavouriteMetadataOptionService, MetadataColumnService, MetadataColumnTemplateService, MetadataColumnTemplateShareService, MetadataManagementService, MetadataTableService, MetadataTableTemplateService, OntologySearchService, OntologyType, OntologyTypeLabels, OntologyUtils, SDRFDefaultsService, SamplePoolService, SchemaService, TASK_STATUS_COLORS, TASK_STATUS_LABELS, TASK_TYPE_LABELS, TemplatePermissionLabels, TemplatePermissionLevel, isUnimodFullData };
+//# sourceMappingURL=noatgnu-cupcake-vanilla.mjs.map