@vcd/sdk 0.13.0 → 15.0.0-alpha.0

package/esm2020/client/client/vcd.http.client.mjs

@@ -0,0 +1,52 @@
+import { HttpClient } from '@angular/common/http';
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+import * as i2 from "./logging.interceptor";
+import * as i3 from "./request.headers.interceptor";
+import * as i4 from "./response.normalization.interceptor";
+/**
+ * Angular's HttpInterceptorHandler is not publicly exposed.  This is a clone of it.
+ */
+class VcdHttpInterceptorHandler {
+    constructor(next, interceptor) {
+        this.next = next;
+        this.interceptor = interceptor;
+    }
+    handle(req) {
+        return this.interceptor.intercept(req, this.next);
+    }
+}
+/**
+ * This is a specialist subclass of HttpClient.  The HttpClient that is defined/imported
+ * by HttpClientModule is a singleton from the container, meaning that all extensions would
+ * get the same one.  We sub-class it so that each extension gets their own instance.
+ * Extension consumers should inject this.
+ * @see HttpClient
+ */
+export class VcdHttpClient extends HttpClient {
+    /**
+     * Create an HttpClient with the logging and header interceptors in the chain.
+     * @param httpBackend backend (likely injected from HttpClientModule)
+     * @param hateoasHeaderInterceptor the hateoas header interceptor
+     * @param loggingInterceptor the logging interceptor
+     * @param requestHeadersInterceptor the request header interceptor
+     */
+    constructor(httpBackend, loggingInterceptor, requestHeadersInterceptor, responseNormalizationInterceptor) {
+        const interceptors = [
+            loggingInterceptor,
+            requestHeadersInterceptor,
+            responseNormalizationInterceptor
+        ];
+        const chain = interceptors.reduceRight((next, interceptor) => new VcdHttpInterceptorHandler(next, interceptor), httpBackend);
+        super(chain);
+        this.loggingInterceptor = loggingInterceptor;
+        this.requestHeadersInterceptor = requestHeadersInterceptor;
+    }
+}
+VcdHttpClient.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.2.0", ngImport: i0, type: VcdHttpClient, deps: [{ token: i1.HttpBackend }, { token: i2.LoggingInterceptor }, { token: i3.RequestHeadersInterceptor }, { token: i4.ResponseNormalizationInterceptor }], target: i0.ɵɵFactoryTarget.Injectable });
+VcdHttpClient.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.2.0", ngImport: i0, type: VcdHttpClient });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.0", ngImport: i0, type: VcdHttpClient, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i1.HttpBackend }, { type: i2.LoggingInterceptor }, { type: i3.RequestHeadersInterceptor }, { type: i4.ResponseNormalizationInterceptor }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/client/client/vcd.transfer.client.mjs

@@ -0,0 +1,166 @@
+import { HttpHeaders } from '@angular/common/http';
+import { Observable, throwError } from 'rxjs';
+import { catchError, flatMap, map, retry, switchMap } from 'rxjs/operators';
+/**
+ * Default chunk size is 50MiB.  This is equal to the chunk size the VCD UI uses for library uploads.
+ */
+export const MAX_CHUNK_SIZE = 50 * 1024 * 1024;
+/**
+ * How many times to retry a chunk upload.
+ */
+export const MAX_CHUNK_RETRY_COUNT = 5;
+/**
+ * A special error thrown by the transfer client.  It gives access to the causing error, and the final progress
+ * before the error occurred.
+ */
+export class TransferError extends Error {
+    constructor(message, originalError, lastProgress) {
+        super(message);
+        this.originalError = originalError;
+        this.lastProgress = lastProgress;
+    }
+}
+/**
+ * This is used to upload files to a VCD API transfer URL.  It is not suggested to create this class - instead
+ * use the startTransfer method in VcdApiClient.
+ */
+export class VcdTransferClient {
+    /**
+     * Create a transfer client.
+     * @param httpClient the http client to be used
+     * @param transferUrl the URL to upload to
+     */
+    constructor(httpClient, transferUrl, maxChunkSize = MAX_CHUNK_SIZE, maxChunkRetryCount = MAX_CHUNK_RETRY_COUNT) {
+        this.httpClient = httpClient;
+        this.transferUrl = transferUrl;
+        this.maxChunkSize = maxChunkSize;
+        this.maxChunkRetryCount = maxChunkRetryCount;
+    }
+    /**
+     * Upload data, optionally listening for progress updates.
+     * @param source what to upload.
+     * @param progressObserver (optional) this will get progress notifications during the upload
+     * @returns fetails of the finished upload.
+     * @throws TransferError when a chunk upload fails.
+     */
+    upload(source, progressObserver) {
+        // Cache the client and url so they don't change from under us.
+        const { httpClient, transferUrl, maxChunkSize, maxChunkRetryCount } = this;
+        // Compute static information used through the upload.
+        const filename = source.name || '<blob>';
+        const totalChunks = Math.ceil(source.size / maxChunkSize);
+        const totalBytes = source.size;
+        const startTimeMs = new Date().getTime();
+        let retryCount = 0;
+        // This helper function creates a TransferProgress object for sending to the progressObserver.
+        // It relies on the above static information, hence being nested.
+        function createTransferProgress(retryNumber, rtryCount, chunksSent) {
+            const chunksRemaining = totalChunks - chunksSent;
+            const bytesSent = Math.min(chunksSent * maxChunkSize, totalBytes);
+            const bytesRemaining = totalBytes - bytesSent;
+            const percent = bytesSent / totalBytes * 100;
+            const timeTakenMs = new Date().getTime() - startTimeMs;
+            const estimatedTotalTimeMs = (bytesSent / bytesRemaining) * timeTakenMs;
+            const estimatedTimeRemainingMs = Math.max(estimatedTotalTimeMs - timeTakenMs, 0);
+            return {
+                filename, transferUrl, retryNumber, retryCount: rtryCount,
+                chunksSent, chunksRemaining, bytesSent, bytesRemaining,
+                percent, timeTakenMs, estimatedTimeRemainingMs
+            };
+        }
+        // This is the main chunk upload function
+        function transferChunk(chunkIndex) {
+            // Calculate chunk details.
+            const chunkStart = chunkIndex * maxChunkSize;
+            const chunkEnd = Math.min(chunkStart + maxChunkSize, totalBytes);
+            const contentRangeHeader = `bytes ${chunkStart}-${chunkEnd - 1}/${totalBytes}`;
+            // Dispatch progress
+            if (progressObserver) {
+                const progress = createTransferProgress(0, retryCount, chunkIndex);
+                progressObserver.next(progress);
+            }
+            // Read in the chunk
+            return Observable.create(observer => {
+                const chunkSlice = source.slice(chunkStart, chunkEnd);
+                const fileReader = new FileReader();
+                fileReader.onerror = err => {
+                    observer.error(err);
+                };
+                fileReader.onabort = err => {
+                    observer.error(err);
+                };
+                fileReader.onload = () => {
+                };
+                fileReader.onloadend = () => {
+                    observer.next(fileReader.result);
+                    observer.complete();
+                };
+                return fileReader.readAsArrayBuffer(chunkSlice);
+                // Transfer the chunk
+            }).pipe(
+            // Upon read error, abort the upload process.  No point retrying read failures.
+            catchError((e) => {
+                // Abandon the upload and propagate a consumable error.
+                const progress = createTransferProgress(0, retryCount, chunkIndex);
+                return throwError(() => new TransferError('Read error', e, progress));
+            }), 
+            // Upon successful read, transfer the chunk.
+            switchMap((data) => {
+                let retryNumber = 0;
+                return httpClient.put(transferUrl, data, {
+                    headers: new HttpHeaders({
+                        'Content-Range': contentRangeHeader
+                    }),
+                    responseType: 'text'
+                }).pipe(
+                // This is called upon any chunk upload failure.
+                catchError((e) => {
+                    // Increase the total retry count.
+                    retryCount++;
+                    // Increase the current chunk retry number.
+                    retryNumber++;
+                    // Dispatch progress (the retry information has changed).
+                    if (progressObserver) {
+                        const progress = createTransferProgress(retryNumber, retryCount, chunkIndex);
+                        progressObserver.next(progress);
+                    }
+                    // Rethrow the error so that the "retry" call handles it.
+                    return throwError(() => e);
+                }), 
+                // Retry the chunk upload up to the limit - this will run the entire chain again.
+                retry(maxChunkRetryCount), 
+                // This is called when all retries for the chunk are exhausted.
+                catchError((e) => {
+                    // Abandon the upload and propagate a consumable error.
+                    const progress = createTransferProgress(retryNumber, retryCount, chunkIndex);
+                    return throwError(() => new TransferError('Transfer error', e, progress));
+                }));
+            }));
+        }
+        // This creates the final transfer progress, dispatches it, and returns the transfer result.
+        function finishUpload() {
+            const transferProgress = createTransferProgress(0, retryCount, totalChunks);
+            if (progressObserver) {
+                progressObserver.next(transferProgress);
+                progressObserver.complete();
+            }
+            const transferResult = {
+                filename: transferProgress.filename,
+                transferUrl: transferProgress.transferUrl,
+                retryCount: transferProgress.retryCount,
+                chunksSent: transferProgress.chunksSent,
+                bytesSent: transferProgress.bytesSent,
+                timeTakenMs: transferProgress.timeTakenMs
+            };
+            return transferResult;
+        }
+        // Upload all of the chunks
+        let chain = transferChunk(0);
+        for (let currentChunk = 1; currentChunk < totalChunks; currentChunk++) {
+            chain = chain.pipe(flatMap(() => transferChunk(currentChunk)));
+        }
+        // Finish transfer
+        return chain.pipe(map(finishUpload));
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"vcd.transfer.client.js","sourceRoot":"","sources":["../../../../../../projects/vcd/sdk/src/client/client/vcd.transfer.client.ts"],"names":[],"mappings":"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","sourcesContent":["import {HttpHeaders, HttpResponse} from '@angular/common/http';\nimport {Observable, Observer, throwError} from 'rxjs';\nimport {catchError, expand, flatMap, last, map, reduce, retry, switchMap, tap} from 'rxjs/operators';\nimport {VcdHttpClient} from './vcd.http.client';\n\n/**\n * Default chunk size is 50MiB.  This is equal to the chunk size the VCD UI uses for library uploads.\n */\nexport const MAX_CHUNK_SIZE = 50 * 1024 * 1024;\n\n/**\n * How many times to retry a chunk upload.\n */\nexport const MAX_CHUNK_RETRY_COUNT = 5;\n\n/**\n * Details about a completed file transfer.\n */\nexport interface TransferResult {\n    /**\n     * Filename being transferred.\n     */\n    filename: string|'<blob>';\n\n    /**\n     * URL being used for the transfer.\n     */\n    transferUrl: string;\n\n    /**\n     * How many retries in total were required\n     */\n    retryCount: number;\n\n    /**\n     * The number of chunks that have been sent.\n     */\n    chunksSent: number;\n\n    /**\n     * How many bytes have been sent.\n     */\n    bytesSent: number;\n\n    /**\n     * How many milliseconds that have elapsed since starting the transfer.\n     */\n    timeTakenMs: number;\n}\n\n/**\n * Details about a file transfer in progress.\n */\nexport interface TransferProgress {\n    /**\n     * Filename being transferred.\n     */\n    filename: string|'<blob>';\n\n    /**\n     * URL being used for the transfer.\n     */\n    transferUrl: string;\n\n    /**\n     * The current retry number for the current chunk.\n     */\n    retryNumber: number;\n\n    /**\n     * The number of retries in total.\n     */\n    retryCount: number;\n\n    /**\n     * The number of chunks that have been sent.\n     */\n    chunksSent: number;\n\n    /**\n     * The number of chunks remaining.\n     */\n    chunksRemaining: number;\n\n    /**\n     * How many bytes have been sent.\n     */\n    bytesSent: number;\n\n    /**\n     * How many bytes remaining to be sent.\n     */\n    bytesRemaining: number;\n\n    /**\n     * Percentage completion.\n     */\n    percent: number;\n\n    /**\n     * How many milliseconds that have elapsed since starting the transfer.\n     */\n    timeTakenMs: number;\n\n    /**\n     * Naive estimate of time remaining.  This is not scientific at all - a simple linear extrapolation.\n     */\n    estimatedTimeRemainingMs: number;\n}\n\n/**\n * A special error thrown by the transfer client.  It gives access to the causing error, and the final progress\n * before the error occurred.\n */\nexport class TransferError extends Error {\n    constructor(message: string, readonly originalError: any, readonly lastProgress: TransferProgress) {\n        super(message);\n    }\n}\n\n/**\n * This is used to upload files to a VCD API transfer URL.  It is not suggested to create this class - instead\n * use the startTransfer method in VcdApiClient.\n */\nexport class VcdTransferClient {\n    /**\n     * Create a transfer client.\n     * @param httpClient the http client to be used\n     * @param transferUrl the URL to upload to\n     */\n    constructor(public httpClient: VcdHttpClient, public transferUrl: string,\n                public maxChunkSize = MAX_CHUNK_SIZE, public maxChunkRetryCount = MAX_CHUNK_RETRY_COUNT) {\n    }\n\n    /**\n     * Upload data, optionally listening for progress updates.\n     * @param source what to upload.\n     * @param progressObserver (optional) this will get progress notifications during the upload\n     * @returns fetails of the finished upload.\n     * @throws TransferError when a chunk upload fails.\n     */\n    upload(source: Blob|File, progressObserver?: Observer<TransferProgress>): Observable<TransferResult> {\n        // Cache the client and url so they don't change from under us.\n        const {httpClient, transferUrl, maxChunkSize, maxChunkRetryCount} = this;\n\n        // Compute static information used through the upload.\n        const filename = (source as File).name || '<blob>';\n        const totalChunks = Math.ceil(source.size / maxChunkSize);\n        const totalBytes = source.size;\n        const startTimeMs = new Date().getTime();\n        let retryCount = 0;\n\n        // This helper function creates a TransferProgress object for sending to the progressObserver.\n        // It relies on the above static information, hence being nested.\n        function createTransferProgress(retryNumber: number, rtryCount: number, chunksSent: number): TransferProgress {\n            const chunksRemaining = totalChunks - chunksSent;\n            const bytesSent = Math.min(chunksSent * maxChunkSize, totalBytes);\n            const bytesRemaining = totalBytes - bytesSent;\n            const percent = bytesSent / totalBytes * 100;\n            const timeTakenMs = new Date().getTime() - startTimeMs;\n            const estimatedTotalTimeMs = (bytesSent / bytesRemaining) * timeTakenMs;\n            const estimatedTimeRemainingMs = Math.max(estimatedTotalTimeMs - timeTakenMs, 0);\n            return {\n                filename,  transferUrl, retryNumber, retryCount: rtryCount,\n                chunksSent, chunksRemaining, bytesSent, bytesRemaining,\n                percent, timeTakenMs, estimatedTimeRemainingMs\n            };\n        }\n\n        // This is the main chunk upload function\n        function transferChunk(chunkIndex: number): Observable<HttpResponse<any>> {\n            // Calculate chunk details.\n            const chunkStart = chunkIndex * maxChunkSize;\n            const chunkEnd = Math.min(chunkStart + maxChunkSize, totalBytes);\n            const contentRangeHeader = `bytes ${chunkStart}-${chunkEnd - 1}/${totalBytes}`;\n\n            // Dispatch progress\n            if (progressObserver) {\n                const progress = createTransferProgress(0, retryCount, chunkIndex);\n                progressObserver.next(progress);\n            }\n\n            // Read in the chunk\n            return Observable.create(observer => {\n                const chunkSlice: Blob = source.slice(chunkStart, chunkEnd);\n                const fileReader = new FileReader();\n                fileReader.onerror = err => {\n                    observer.error(err);\n                };\n                fileReader.onabort = err => {\n                    observer.error(err);\n                };\n                fileReader.onload = () => {\n                };\n                fileReader.onloadend = () => {\n                    observer.next(fileReader.result);\n                    observer.complete();\n                };\n\n                return fileReader.readAsArrayBuffer(chunkSlice);\n\n            // Transfer the chunk\n            }).pipe(\n                // Upon read error, abort the upload process.  No point retrying read failures.\n                catchError((e) => {\n                    // Abandon the upload and propagate a consumable error.\n                    const progress = createTransferProgress(0, retryCount, chunkIndex);\n                    return throwError(() => new TransferError('Read error', e, progress));\n                }),\n\n                // Upon successful read, transfer the chunk.\n                switchMap((data) => {\n                    let retryNumber = 0;\n                    return httpClient.put(\n                        transferUrl, data,\n                        {\n                            headers: new HttpHeaders({\n                                'Content-Range': contentRangeHeader\n                            }),\n                            responseType: 'text'\n                        }\n                    ).pipe(\n                        // This is called upon any chunk upload failure.\n                        catchError((e) => {\n                            // Increase the total retry count.\n                            retryCount++;\n\n                            // Increase the current chunk retry number.\n                            retryNumber++;\n\n                            // Dispatch progress (the retry information has changed).\n                            if (progressObserver) {\n                                const progress = createTransferProgress(retryNumber, retryCount, chunkIndex);\n                                progressObserver.next(progress);\n                            }\n\n                            // Rethrow the error so that the \"retry\" call handles it.\n                            return throwError(() => e);\n                        }),\n\n                        // Retry the chunk upload up to the limit - this will run the entire chain again.\n                        retry(maxChunkRetryCount),\n\n                        // This is called when all retries for the chunk are exhausted.\n                        catchError((e) => {\n                            // Abandon the upload and propagate a consumable error.\n                            const progress = createTransferProgress(retryNumber, retryCount, chunkIndex);\n                            return throwError(() => new TransferError('Transfer error', e, progress));\n                        })\n                    );\n                })\n            );\n        }\n\n        // This creates the final transfer progress, dispatches it, and returns the transfer result.\n        function finishUpload(): TransferResult {\n            const transferProgress = createTransferProgress(0, retryCount, totalChunks);\n            if (progressObserver) {\n                progressObserver.next(transferProgress);\n                progressObserver.complete();\n            }\n\n            const transferResult: TransferResult = {\n                filename: transferProgress.filename,\n                transferUrl: transferProgress.transferUrl,\n                retryCount: transferProgress.retryCount,\n                chunksSent: transferProgress.chunksSent,\n                bytesSent: transferProgress.bytesSent,\n                timeTakenMs: transferProgress.timeTakenMs\n            };\n            return transferResult;\n        }\n\n        // Upload all of the chunks\n        let chain = transferChunk(0);\n        for (let currentChunk = 1; currentChunk < totalChunks; currentChunk++) {\n            chain = chain.pipe(\n                flatMap(() => transferChunk(currentChunk))\n            );\n        }\n\n        // Finish transfer\n        return chain.pipe(map(finishUpload));\n    }\n}\n"]}

package/esm2020/client/container-hooks/index.mjs

@@ -0,0 +1,57 @@
+/**
+ * This is the currently supported - albeit very minimal - public SDK.
+ */
+import { InjectionToken } from '@angular/core';
+// Bind straight into the hooks provided by the container.
+if (!window.System || !window.System.registry || !window.System.registry.get) {
+    throw new Error('SystemJS registry not found');
+}
+let containerHooks = window.System.registry.get('@vcd/common');
+if (!containerHooks) {
+    containerHooks = window.System.registry.get('@vcd-ui/common');
+}
+if (!containerHooks) {
+    throw new Error('VCD UI container hooks not present in SystemJS registry');
+}
+/**
+ * Wire in as a string.  Gives the root URL for API access (for example, the load balancer URL
+ * or the single-cell URL).
+ */
+export const API_ROOT_URL = containerHooks.API_ROOT_URL;
+/**
+ * Wire in as a string.  Gives the root URL for the legacy Flex application.
+ */
+export const FLEX_APP_URL = containerHooks.API_ROOT_URL;
+/**
+ * Wire in as a string.  Gives the current scope of the VCD-UI.  As of current, this will be
+ * either 'tenant' for the tenant portal, or 'service-provider' for the service-provider portal.
+ */
+export const SESSION_SCOPE = containerHooks.SESSION_SCOPE;
+/**
+ * Wire in as a string.  Gives the unique name (not the display name) of the current tenant
+ * organization that the VCD-UI is being used for.
+ */
+export const SESSION_ORGANIZATION = containerHooks.SESSION_ORGANIZATION;
+/**
+ * Wire in as a string.  Gives the UUID identifier of the current tenant
+ * organization that the VCD-UI is being used for.
+ */
+export const SESSION_ORG_ID = containerHooks.SESSION_ORG_ID ? containerHooks.SESSION_ORG_ID : '';
+/**
+ * Wire in as a string.  Gives the full root path for module assets (e.g. images, scripts, text files)
+ *
+ * ATTENTION!
+ * Add || new InjectionToken to workaround the Angular security mechanics which prevent use of injection tokens
+ * which potentially are not defiend. The same fix can be applied for the rest tokens if needed.
+ */
+export const EXTENSION_ASSET_URL = containerHooks.EXTENSION_ASSET_URL || new InjectionToken('EXTENSION_ASSET_URL');
+/**
+ * Wire in as a string.  Gives the Angular 2 route that the module is registered under.
+ */
+export const EXTENSION_ROUTE = containerHooks.EXTENSION_ROUTE;
+/**
+ * Wire in as a boolean.  True if running under the SDK, false if running in production.
+ */
+export const SDK_MODE = containerHooks.SDK_MODE;
+export const AuthTokenHolderService = containerHooks.AuthTokenHolderService;
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/client/index.mjs

@@ -0,0 +1,3 @@
+export * from './query';
+export * from './client';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy92Y2Qvc2RrL3NyYy9jbGllbnQvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxTQUFTLENBQUM7QUFDeEIsY0FBYyxVQUFVLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL3F1ZXJ5JztcbmV4cG9ydCAqIGZyb20gJy4vY2xpZW50JzsiXX0=

package/esm2020/client/openapi.mjs

@@ -0,0 +1,16 @@
+/**
+ * Entity reference used to describe VCD entities
+ */
+export class EntityReference {
+}
+/**
+ * Session
+ */
+export class Session {
+}
+/**
+ * A location accessible to this session.
+ */
+export class AccessibleLocation {
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/client/query/filter.builder.mjs

@@ -0,0 +1,195 @@
+// tslint:disable-next-line:no-namespace
+export var Filter;
+(function (Filter) {
+    class Operators {
+    }
+    Operators.OR = ',';
+    Operators.AND = ';';
+    Operators.GT = '=gt=';
+    Operators.GE = '=ge=';
+    Operators.LT = '=lt=';
+    Operators.LE = '=le=';
+    Operators.EQ = '==';
+    Operators.NEQ = '!=';
+    /**
+     * Collection of strategies for wilcard string matching.
+     */
+    class MatchMode {
+    }
+    /**
+     * Match the start of a string.
+     */
+    MatchMode.START = 'START';
+    /**
+     * Match the end of a string.
+     */
+    MatchMode.END = 'END';
+    /**
+     * Match anywhere in the string.
+     */
+    MatchMode.ANYWHERE = 'ANYWHERE';
+    Filter.MatchMode = MatchMode;
+    class BuilderChain {
+        constructor(parent) {
+            this.result = '';
+            this.parent = parent;
+        }
+        query() {
+            return this.buildPartial();
+        }
+        // tslint:disable-next-line:max-line-length
+        and(condition1, condition2, conditionN) {
+            if (!condition1) {
+                return this.simpleAnd();
+            }
+            this.result += '(' + condition1.buildPartial() + Operators.AND + condition2.buildPartial();
+            if (conditionN && conditionN.length) {
+                conditionN.forEach((condition) => {
+                    this.result += Operators.AND + condition.buildPartial();
+                });
+            }
+            this.result += ')';
+            return this;
+        }
+        simpleAnd() {
+            if (this.currentCompositeOp === Operators.OR || this.parent && this.parent.currentCompositeOp === Operators.OR) {
+                if (this.parent) {
+                    this.parent.result = '(' + this.parent.result;
+                    this.result += ')';
+                }
+                else {
+                    this.wrap();
+                }
+                this.currentCompositeOp = Operators.AND;
+            }
+            this.result += Operators.AND;
+            return this;
+        }
+        // tslint:disable-next-line:max-line-length
+        or(condition1, condition2, conditionN) {
+            if (!condition1) {
+                return this.simpleOr();
+            }
+            this.result += '(' + condition1.buildPartial() + Operators.OR + condition2.buildPartial();
+            if (conditionN && conditionN.length) {
+                conditionN.forEach((condition) => {
+                    this.result += Operators.OR + condition.buildPartial();
+                });
+            }
+            this.result += ')';
+            return this;
+        }
+        simpleOr() {
+            if (this.currentCompositeOp === Operators.AND || (this.parent && this.parent.currentCompositeOp === Operators.AND)) {
+                if (this.parent) {
+                    this.parent.result = '(' + this.parent.result;
+                    this.result += ')';
+                }
+                else {
+                    this.wrap();
+                }
+                this.currentCompositeOp = Operators.OR;
+            }
+            this.result += Operators.OR;
+            return this;
+        }
+        wrap() {
+            this.result = '(' + this.result + ')';
+            this.currentCompositeOp = null;
+            return this;
+        }
+        buildPartial() {
+            return (this.parent) ? this.parent.buildPartial() + this.result : this.result;
+        }
+        is(property) {
+            const builder = new BuilderChain(this);
+            builder.result = property;
+            return builder;
+        }
+        equalTo(value, ...moreValues) {
+            return this.condition(Operators.EQ, value, ...moreValues);
+        }
+        notEqualTo(value) {
+            return this.condition(Operators.NEQ, value);
+        }
+        lessThan(value) {
+            return this.condition(Operators.LT, value);
+        }
+        lessOrEqualTo(value) {
+            return this.condition(Operators.LE, value);
+        }
+        greaterThan(value) {
+            return this.condition(Operators.GT, value);
+        }
+        greaterOrEqualTo(value) {
+            return this.condition(Operators.GE, value);
+        }
+        like(value, mode = MatchMode.START) {
+            let wildcardValue;
+            switch (mode) {
+                case MatchMode.START:
+                    wildcardValue = `${value}*`;
+                    break;
+                case MatchMode.END:
+                    wildcardValue = `*${value}`;
+                    break;
+                case MatchMode.ANYWHERE:
+                    wildcardValue = `*${value}*`;
+                    break;
+                default:
+                    wildcardValue = value;
+                    break;
+            }
+            return this.condition(Operators.EQ, wildcardValue);
+        }
+        condition(operator, value, ...moreValues) {
+            const name = this.result;
+            this.result += operator + encodeURI(value);
+            if (moreValues.length) {
+                moreValues.forEach((next) => {
+                    this.result += ',' + name + operator + encodeURI(next);
+                });
+                this.currentCompositeOp = Operators.OR;
+            }
+            return this;
+        }
+    }
+    /**
+     * Builds a FIQL search condition using a fluent interface.
+     */
+    class Builder {
+        /**
+         * Create a simple property to be evaulated as a filter condition.
+         *
+         * @param property the name of the property
+         * @returns a Property instance for defining a filter condition
+         */
+        is(property) {
+            return new BuilderChain().is(property);
+        }
+        /**
+         * Create a conjunction (AND) condition from existing conditions.
+         *
+         * @param condition1 first condition
+         * @param condition2 second condition
+         * @param conditionN any additional conditions
+         * @returns an evaluatable filter condition
+         */
+        and(condition1, condition2, conditionN) {
+            return new BuilderChain().and(condition1, condition2, conditionN);
+        }
+        /**
+         * Create a disjunction (OR) condition from existing conditions.
+         *
+         * @param condition1 first condition
+         * @param condition2 second condition
+         * @param conditionN any additional conditions
+         * @returns an evaluatable filter condition
+         */
+        or(condition1, condition2, conditionN) {
+            return new BuilderChain().or(condition1, condition2, conditionN);
+        }
+    }
+    Filter.Builder = Builder;
+})(Filter || (Filter = {}));
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"filter.builder.js","sourceRoot":"","sources":["../../../../../../projects/vcd/sdk/src/client/query/filter.builder.ts"],"names":[],"mappings":"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","sourcesContent":["// tslint:disable-next-line:no-namespace\nexport namespace Filter {\n    class Operators {\n        public static readonly OR: string = ',';\n        public static readonly AND: string = ';';\n        public static readonly GT: string = '=gt=';\n        public static readonly GE: string = '=ge=';\n        public static readonly LT: string = '=lt=';\n        public static readonly LE: string = '=le=';\n        public static readonly EQ: string = '==';\n        public static readonly NEQ: string = '!=';\n    }\n\n    /**\n     * Collection of strategies for wilcard string matching.\n     */\n    export class MatchMode {\n        /**\n         * Match the start of a string.\n         */\n        public static readonly START: string = 'START';\n\n        /**\n         * Match the end of a string.\n         */\n        public static readonly END: string = 'END';\n\n        /**\n         * Match anywhere in the string.\n         */\n        public static readonly ANYWHERE: string = 'ANYWHERE';\n    }\n\n    /**\n     * A filter item that can define a comparison/condition.\n     */\n    export interface Property {\n        /**\n         * Create a filter condition to evaluate whether the property is equal to the specified value.\n         *\n         * @param value the pattern to evaluate\n         * @param moreValues optional additional patterns to evaluate that will be treated as an OR condition\n         * @returns an evaluatable filter condition\n         */\n        equalTo(value: (boolean | number | string), ...moreValues: (boolean | number | string)[]): CompleteCondition;\n\n        /**\n         * Create a filter condition to evaluate whether the property is not equal to the specified value.\n         *\n         * @param value the pattern to evaluate\n         * @returns an evaluatable filter condition\n         */\n        notEqualTo(value: (boolean | number | string)): CompleteCondition;\n\n        /**\n         * Create a filter condition to evaluate whether the property is less than the specified value.\n         *\n         * @param value the pattern to evaluate\n         * @returns an evaluatable filter condition\n         */\n        lessThan(value: number): CompleteCondition;\n\n        /**\n         * Create a filter condition to evaluate whether the property is less than or equal to the specified value.\n         *\n         * @param value the pattern to evaluate\n         * @returns an evaluatable filter condition\n         */\n        lessOrEqualTo(value: number): CompleteCondition;\n\n        /**\n         * Create a filter condition to evaluate whether the property is greater than the specified value.\n         *\n         * @param value the pattern to evaluate\n         * @returns an evaluatable filter condition\n         */\n        greaterThan(value: number): CompleteCondition;\n\n        /**\n         * Create a filter condition to evaluate whether the property is greater than or equal to the specified value.\n         *\n         * @param value the pattern to evaluate\n         * @returns an evaluatable filter condition\n         */\n        greaterOrEqualTo(value: number): CompleteCondition;\n\n        /**\n         * Create a filter condition to evaluate whether the property is a wildcard match with the specified value.\n         *\n         * @param value the pattern to evaluate\n         * @param mode the type of wildcard evaluation to perform\n         * @returns an evaluatable filter condition\n         */\n        like(value: string, mode: MatchMode): CompleteCondition;\n    }\n\n    /**\n     * A representation of a condition that is incomplete by itself, like an empty condition, aggregation wrapper, or junction.\n     */\n    export interface PartialCondition {\n        /**\n         * Create a simple property to be evaulated as a filter condition.\n         *\n         * @param property the name of the property\n         * @returns a Property instance for defining a filter condition\n         */\n        is(property: string): Property;\n\n        /**\n         * Create a conjunction (AND) condition from existing conditions.\n         *\n         * @param condition1 first condition\n         * @param condition2 second condition\n         * @param conditionN any additional conditions\n         * @returns an evaluatable filter condition\n         */\n        and(condition1: CompleteCondition, condition2: CompleteCondition, conditionN?: CompleteCondition[]): CompleteCondition;\n\n        /**\n         * Create a disjunction (OR) condition from existing conditions.\n         *\n         * @param condition1 first condition\n         * @param condition2 second condition\n         * @param conditionN any additional conditions\n         * @returns an evaluatable filter condition\n         */\n        or(condition1: CompleteCondition, condition2: CompleteCondition, conditionN?: CompleteCondition[]): CompleteCondition;\n    }\n\n    /**\n     * An evaluatable filter condition.\n     */\n    export interface CompleteCondition {\n        /**\n         * Add a condtion to this condition.\n         *\n         * This new condition will be ANDed to the existing condition.\n         *\n         * @returns an incomplete (empty) condition\n         */\n        and(): PartialCondition;\n\n        /**\n         * Add a condtion to this condition.\n         *\n         * This new condition will be ORed to the existing condition.\n         *\n         * @returns an incomplete (empty) condition\n         */\n        or(): PartialCondition;\n\n        /**\n         * Build the FIQL representation of the condition.\n         *\n         * @returns a FIQL string\n         */\n        query(): string;\n    }\n\n    class BuilderChain implements CompleteCondition, PartialCondition, Property {\n        private result = '';\n        private parent: BuilderChain;\n        private currentCompositeOp: string;\n\n        constructor(parent?: BuilderChain) {\n            this.parent = parent;\n        }\n\n        public query(): string {\n            return this.buildPartial();\n        }\n\n        public and(): PartialCondition;\n        public and(condition1: CompleteCondition, condition2: CompleteCondition, conditionN?: CompleteCondition[]): CompleteCondition;\n        // tslint:disable-next-line:max-line-length\n        public and(condition1?: CompleteCondition, condition2?: CompleteCondition, conditionN?: CompleteCondition[]): PartialCondition | CompleteCondition {\n            if (!condition1) {\n                return this.simpleAnd();\n            }\n\n            this.result += '(' + (condition1 as BuilderChain).buildPartial() + Operators.AND + (condition2 as BuilderChain).buildPartial();\n            if (conditionN && conditionN.length) {\n                conditionN.forEach((condition) => {\n                    this.result += Operators.AND + (condition as BuilderChain).buildPartial();\n                });\n            }\n\n            this.result += ')';\n            return this;\n        }\n\n        private simpleAnd(): PartialCondition {\n            if (this.currentCompositeOp === Operators.OR || this.parent && this.parent.currentCompositeOp === Operators.OR) {\n                if (this.parent) {\n                    this.parent.result = '(' + this.parent.result;\n                    this.result += ')';\n                } else {\n                    this.wrap();\n                }\n\n                this.currentCompositeOp = Operators.AND;\n            }\n\n            this.result += Operators.AND;\n            return this;\n        }\n\n        public or(): PartialCondition;\n        public or(condition1: CompleteCondition, condition2: CompleteCondition, conditionN?: CompleteCondition[]): CompleteCondition;\n        // tslint:disable-next-line:max-line-length\n        public or(condition1?: CompleteCondition, condition2?: CompleteCondition, conditionN?: CompleteCondition[]): PartialCondition | CompleteCondition {\n            if (!condition1) {\n                return this.simpleOr();\n            }\n\n            this.result += '(' + (condition1 as BuilderChain).buildPartial() + Operators.OR + (condition2 as BuilderChain).buildPartial();\n            if (conditionN && conditionN.length) {\n                conditionN.forEach((condition) => {\n                    this.result += Operators.OR + (condition as BuilderChain).buildPartial();\n                });\n            }\n\n            this.result += ')';\n            return this;\n        }\n\n        private simpleOr(): PartialCondition {\n            if (this.currentCompositeOp === Operators.AND || (this.parent && this.parent.currentCompositeOp === Operators.AND)) {\n                if (this.parent) {\n                    this.parent.result = '(' + this.parent.result;\n                    this.result += ')';\n                } else {\n                    this.wrap();\n                }\n\n                this.currentCompositeOp = Operators.OR;\n            }\n\n            this.result += Operators.OR;\n            return this;\n        }\n\n        private wrap(): CompleteCondition {\n            this.result = '(' + this.result + ')';\n            this.currentCompositeOp = null;\n            return this;\n        }\n\n        private buildPartial(): string {\n            return (this.parent) ? this.parent.buildPartial() + this.result : this.result;\n        }\n\n        public is(property: string): Property {\n            const builder: BuilderChain = new BuilderChain(this);\n            builder.result = property;\n            return builder;\n        }\n\n        public equalTo(value: (boolean | number | string), ...moreValues: (boolean | number | string)[]): CompleteCondition {\n            return this.condition(Operators.EQ, value, ...moreValues);\n        }\n\n        public notEqualTo(value: (boolean | number | string)): CompleteCondition {\n            return this.condition(Operators.NEQ, value);\n        }\n\n        public lessThan(value: number): CompleteCondition {\n            return this.condition(Operators.LT, value);\n        }\n\n        public lessOrEqualTo(value: number): CompleteCondition {\n            return this.condition(Operators.LE, value);\n        }\n\n        public greaterThan(value: number): CompleteCondition {\n            return this.condition(Operators.GT, value);\n        }\n\n        public greaterOrEqualTo(value: number): CompleteCondition {\n            return this.condition(Operators.GE, value);\n        }\n\n        public like(value: string, mode: MatchMode = MatchMode.START): CompleteCondition {\n            let wildcardValue: string;\n            switch (mode) {\n                case MatchMode.START:\n                    wildcardValue = `${value}*`;\n                    break;\n                case MatchMode.END:\n                    wildcardValue = `*${value}`;\n                    break;\n                case MatchMode.ANYWHERE:\n                    wildcardValue = `*${value}*`;\n                    break;\n                default:\n                    wildcardValue = value;\n                    break;\n            }\n\n            return this.condition(Operators.EQ, wildcardValue);\n        }\n\n        private condition(operator: string, value: any, ...moreValues: any[]): CompleteCondition {\n            const name = this.result;\n            this.result += operator + encodeURI(value as string);\n            if (moreValues.length) {\n                moreValues.forEach((next) => {\n                    this.result += ',' + name + operator + encodeURI(next as string);\n                });\n\n                this.currentCompositeOp = Operators.OR;\n            }\n\n            return this;\n        }\n    }\n\n    /**\n     * Builds a FIQL search condition using a fluent interface.\n     */\n    export class Builder implements PartialCondition {\n        /**\n         * Create a simple property to be evaulated as a filter condition.\n         *\n         * @param property the name of the property\n         * @returns a Property instance for defining a filter condition\n         */\n        is(property: string): Property {\n            return new BuilderChain().is(property);\n        }\n\n        /**\n         * Create a conjunction (AND) condition from existing conditions.\n         *\n         * @param condition1 first condition\n         * @param condition2 second condition\n         * @param conditionN any additional conditions\n         * @returns an evaluatable filter condition\n         */\n        and(condition1: CompleteCondition, condition2: CompleteCondition, conditionN?: CompleteCondition[]): CompleteCondition {\n            return new BuilderChain().and(condition1, condition2, conditionN);\n        }\n\n        /**\n         * Create a disjunction (OR) condition from existing conditions.\n         *\n         * @param condition1 first condition\n         * @param condition2 second condition\n         * @param conditionN any additional conditions\n         * @returns an evaluatable filter condition\n         */\n        or(condition1: CompleteCondition, condition2: CompleteCondition, conditionN?: CompleteCondition[]): CompleteCondition {\n            return new BuilderChain().or(condition1, condition2, conditionN);\n        }\n    }\n}\n"]}

package/esm2020/client/query/index.mjs

@@ -0,0 +1,3 @@
+export * from './query.builder';
+export * from './filter.builder';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy92Y2Qvc2RrL3NyYy9jbGllbnQvcXVlcnkvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxpQkFBaUIsQ0FBQztBQUNoQyxjQUFjLGtCQUFrQixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9xdWVyeS5idWlsZGVyJztcbmV4cG9ydCAqIGZyb20gJy4vZmlsdGVyLmJ1aWxkZXInO1xuIl19