@vcd/sdk 15.0.8 → 17.0.0

package/{esm2020 → esm2022}/client/client/vcd.http.client.mjs

@@ -47,15 +47,15 @@ export class VcdHttpClient extends HttpClient {
         this.loggingInterceptor = loggingInterceptor;
         this.requestHeadersInterceptor = requestHeadersInterceptor;
     }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.1.2", ngImport: i0, type: VcdHttpClient, deps: [{ token: i1.HttpBackend }, { token: i2.LoggingInterceptor }, { token: i3.RequestHeadersInterceptor }, { token: i4.ResponseNormalizationInterceptor }, { token: VCD_HTTP_INTERCEPTORS, optional: true }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.1.2", ngImport: i0, type: VcdHttpClient }); }
 }
-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 }, { token: VCD_HTTP_INTERCEPTORS, optional: true }], 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: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.1.2", ngImport: i0, type: VcdHttpClient, decorators: [{
             type: Injectable
-        }], ctorParameters: function () { return [{ type: i1.HttpBackend }, { type: i2.LoggingInterceptor }, { type: i3.RequestHeadersInterceptor }, { type: i4.ResponseNormalizationInterceptor }, { type: undefined, decorators: [{
+        }], ctorParameters: () => [{ type: i1.HttpBackend }, { type: i2.LoggingInterceptor }, { type: i3.RequestHeadersInterceptor }, { type: i4.ResponseNormalizationInterceptor }, { type: undefined, decorators: [{
                     type: Optional
                 }, {
                     type: Inject,
                     args: [VCD_HTTP_INTERCEPTORS]
-                }] }]; } });
-//# sourceMappingURL=data:application/json;base64,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
+                }] }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/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/esm2022/client/query/filter.builder.mjs

@@ -0,0 +1,195 @@
+// tslint:disable-next-line:no-namespace
+export var Filter;
+(function (Filter) {
+    class Operators {
+        static { this.OR = ','; }
+        static { this.AND = ';'; }
+        static { this.GT = '=gt='; }
+        static { this.GE = '=ge='; }
+        static { this.LT = '=lt='; }
+        static { this.LE = '=le='; }
+        static { this.EQ = '=='; }
+        static { this.NEQ = '!='; }
+    }
+    /**
+     * Collection of strategies for wilcard string matching.
+     */
+    class MatchMode {
+        /**
+         * Match the start of a string.
+         */
+        static { this.START = 'START'; }
+        /**
+         * Match the end of a string.
+         */
+        static { this.END = 'END'; }
+        /**
+         * Match anywhere in the string.
+         */
+        static { this.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/esm2022/client/query/query.builder.mjs

@@ -0,0 +1,79 @@
+// tslint:disable:variable-name
+// tslint:disable-next-line:no-namespace
+export var Query;
+(function (Query) {
+    class Builder {
+        constructor() {
+            this._format = Format.ID_RECORDS;
+            this._links = true;
+            this._pageSize = 25;
+        }
+        static getBuilder() {
+            return new Builder();
+        }
+        static ofType(type) {
+            const qb = new Builder();
+            qb._type = type;
+            return qb;
+        }
+        format(format) {
+            this._format = format;
+            return this;
+        }
+        links(links) {
+            this._links = links;
+            return this;
+        }
+        pageSize(pageSize) {
+            this._pageSize = pageSize;
+            return this;
+        }
+        fields(...fields) {
+            this._fields = fields;
+            return this;
+        }
+        filter(filter) {
+            this._filter = filter;
+            return this;
+        }
+        sort(...sort) {
+            this._sort = sort;
+            return this;
+        }
+        get() {
+            let query = `?type=${this._type}&format=${this._format}&links=${this._links}&pageSize=${this._pageSize}`;
+            if (this._fields && this._fields.length > 0) {
+                query += `&fields=${this._fields.join(',')}`;
+            }
+            if (this._filter) {
+                query += `&filter=${this._filter}`;
+            }
+            if (this._sort) {
+                this._sort.forEach(s => {
+                    query += `&${s.reverse ? 'sortDesc' : 'sortAsc'}=${s.field}`;
+                });
+            }
+            return query;
+        }
+        getCloudAPI() {
+            let query = `?pageSize=${this._pageSize}`;
+            if (this._filter) {
+                query += `&filter=${this._filter}`;
+            }
+            if (this._sort) {
+                this._sort.forEach(s => {
+                    query += `&${s.reverse ? 'sortDesc' : 'sortAsc'}=${s.field}`;
+                });
+            }
+            return query;
+        }
+    }
+    Query.Builder = Builder;
+    class Format {
+        static { this.ID_RECORDS = 'idrecords'; }
+        static { this.RECORDS = 'records'; }
+        static { this.REFERENCES = 'references'; }
+    }
+    Query.Format = Format;
+})(Query || (Query = {}));
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicXVlcnkuYnVpbGRlci5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL3ZjZC9zZGsvc3JjL2NsaWVudC9xdWVyeS9xdWVyeS5idWlsZGVyLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUVBLCtCQUErQjtBQUMvQix3Q0FBd0M7QUFDeEMsTUFBTSxLQUFXLEtBQUssQ0E2RnJCO0FBN0ZELFdBQWlCLEtBQUs7SUFDbEIsTUFBYSxPQUFPO1FBU2hCO1lBUFEsWUFBTyxHQUFXLE1BQU0sQ0FBQyxVQUFVLENBQUM7WUFDcEMsV0FBTSxHQUFHLElBQUksQ0FBQztZQUNkLGNBQVMsR0FBRyxFQUFFLENBQUM7UUFLQyxDQUFDO1FBRWxCLE1BQU0sQ0FBQyxVQUFVO1lBQ3BCLE9BQU8sSUFBSSxPQUFPLEVBQUUsQ0FBQztRQUN6QixDQUFDO1FBRU0sTUFBTSxDQUFDLE1BQU0sQ0FBQyxJQUFZO1lBQzdCLE1BQU0sRUFBRSxHQUFHLElBQUksT0FBTyxFQUFFLENBQUM7WUFDekIsRUFBRSxDQUFDLEtBQUssR0FBRyxJQUFJLENBQUM7WUFDaEIsT0FBTyxFQUFFLENBQUM7UUFDZCxDQUFDO1FBRU0sTUFBTSxDQUFDLE1BQW9CO1lBQzlCLElBQUksQ0FBQyxPQUFPLEdBQUcsTUFBTSxDQUFDO1lBQ3RCLE9BQU8sSUFBSSxDQUFDO1FBQ2hCLENBQUM7UUFFTSxLQUFLLENBQUMsS0FBYztZQUN2QixJQUFJLENBQUMsTUFBTSxHQUFHLEtBQUssQ0FBQztZQUNwQixPQUFPLElBQUksQ0FBQztRQUNoQixDQUFDO1FBRU0sUUFBUSxDQUFDLFFBQWdCO1lBQzVCLElBQUksQ0FBQyxTQUFTLEdBQUcsUUFBUSxDQUFDO1lBQzFCLE9BQU8sSUFBSSxDQUFDO1FBQ2hCLENBQUM7UUFFTSxNQUFNLENBQUMsR0FBRyxNQUFnQjtZQUM3QixJQUFJLENBQUMsT0FBTyxHQUFHLE1BQU0sQ0FBQztZQUN0QixPQUFPLElBQUksQ0FBQztRQUNoQixDQUFDO1FBRU0sTUFBTSxDQUFDLE1BQWM7WUFDeEIsSUFBSSxDQUFDLE9BQU8sR0FBRyxNQUFNLENBQUM7WUFDdEIsT0FBTyxJQUFJLENBQUM7UUFDaEIsQ0FBQztRQUVNLElBQUksQ0FBQyxHQUFHLElBQTRDO1lBQ3ZELElBQUksQ0FBQyxLQUFLLEdBQUcsSUFBSSxDQUFDO1lBQ2xCLE9BQU8sSUFBSSxDQUFDO1FBQ2hCLENBQUM7UUFFTSxHQUFHO1lBQ04sSUFBSSxLQUFLLEdBQUcsU0FBUyxJQUFJLENBQUMsS0FBSyxXQUFXLElBQUksQ0FBQyxPQUFPLFVBQVUsSUFBSSxDQUFDLE1BQU0sYUFBYSxJQUFJLENBQUMsU0FBUyxFQUFFLENBQUM7WUFDekcsSUFBSSxJQUFJLENBQUMsT0FBTyxJQUFJLElBQUksQ0FBQyxPQUFPLENBQUMsTUFBTSxHQUFHLENBQUMsRUFBRSxDQUFDO2dCQUMxQyxLQUFLLElBQUksV0FBVyxJQUFJLENBQUMsT0FBTyxDQUFDLElBQUksQ0FBQyxHQUFHLENBQUMsRUFBRSxDQUFDO1lBQ2pELENBQUM7WUFFRCxJQUFJLElBQUksQ0FBQyxPQUFPLEVBQUUsQ0FBQztnQkFDZixLQUFLLElBQUksV0FBVyxJQUFJLENBQUMsT0FBTyxFQUFFLENBQUM7WUFDdkMsQ0FBQztZQUVELElBQUksSUFBSSxDQUFDLEtBQUssRUFBRSxDQUFDO2dCQUNiLElBQUksQ0FBQyxLQUFLLENBQUMsT0FBTyxDQUFDLENBQUMsQ0FBQyxFQUFFO29CQUNuQixLQUFLLElBQUksSUFBSSxDQUFDLENBQUMsT0FBTyxDQUFDLENBQUMsQ0FBQyxVQUFVLENBQUMsQ0FBQyxDQUFDLFNBQVMsSUFBSSxDQUFDLENBQUMsS0FBSyxFQUFFLENBQUM7Z0JBQ2pFLENBQUMsQ0FBQyxDQUFDO1lBQ1AsQ0FBQztZQUVELE9BQU8sS0FBSyxDQUFDO1FBQ2pCLENBQUM7UUFFTSxXQUFXO1lBQ2QsSUFBSSxLQUFLLEdBQUcsYUFBYSxJQUFJLENBQUMsU0FBUyxFQUFFLENBQUM7WUFFMUMsSUFBSSxJQUFJLENBQUMsT0FBTyxFQUFFLENBQUM7Z0JBQ2YsS0FBSyxJQUFJLFdBQVcsSUFBSSxDQUFDLE9BQU8sRUFBRSxDQUFDO1lBQ3ZDLENBQUM7WUFFRCxJQUFJLElBQUksQ0FBQyxLQUFLLEVBQUUsQ0FBQztnQkFDYixJQUFJLENBQUMsS0FBSyxDQUFDLE9BQU8sQ0FBQyxDQUFDLENBQUMsRUFBRTtvQkFDbkIsS0FBSyxJQUFJLElBQUksQ0FBQyxDQUFDLE9BQU8sQ0FBQyxDQUFDLENBQUMsVUFBVSxDQUFDLENBQUMsQ0FBQyxTQUFTLElBQUksQ0FBQyxDQUFDLEtBQUssRUFBRSxDQUFDO2dCQUNqRSxDQUFDLENBQUMsQ0FBQztZQUNQLENBQUM7WUFFRCxPQUFPLEtBQUssQ0FBQztRQUNqQixDQUFDO0tBQ0o7SUFyRlksYUFBTyxVQXFGbkIsQ0FBQTtJQUVELE1BQWEsTUFBTTtpQkFDQyxlQUFVLEdBQVcsV0FBVyxDQUFDO2lCQUNqQyxZQUFPLEdBQVcsU0FBUyxDQUFDO2lCQUM1QixlQUFVLEdBQVcsWUFBWSxDQUFDOztJQUh6QyxZQUFNLFNBSWxCLENBQUE7QUFDTCxDQUFDLEVBN0ZnQixLQUFLLEtBQUwsS0FBSyxRQTZGckIiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBGaWx0ZXIgfSBmcm9tICcuL2ZpbHRlci5idWlsZGVyJztcblxuLy8gdHNsaW50OmRpc2FibGU6dmFyaWFibGUtbmFtZVxuLy8gdHNsaW50OmRpc2FibGUtbmV4dC1saW5lOm5vLW5hbWVzcGFjZVxuZXhwb3J0IG5hbWVzcGFjZSBRdWVyeSB7XG4gICAgZXhwb3J0IGNsYXNzIEJ1aWxkZXIge1xuICAgICAgICBwcml2YXRlIF90eXBlOiBzdHJpbmc7XG4gICAgICAgIHByaXZhdGUgX2Zvcm1hdDogRm9ybWF0ID0gRm9ybWF0LklEX1JFQ09SRFM7XG4gICAgICAgIHByaXZhdGUgX2xpbmtzID0gdHJ1ZTtcbiAgICAgICAgcHJpdmF0ZSBfcGFnZVNpemUgPSAyNTtcbiAgICAgICAgcHJpdmF0ZSBfZmllbGRzOiBzdHJpbmdbXTtcbiAgICAgICAgcHJpdmF0ZSBfZmlsdGVyOiBzdHJpbmc7XG4gICAgICAgIHByaXZhdGUgX3NvcnQ6IHsgZmllbGQ6IHN0cmluZywgcmV2ZXJzZT86IGJvb2xlYW4gfVtdO1xuXG4gICAgICAgIHByaXZhdGUgY29uc3RydWN0b3IoKSB7IH1cblxuICAgICAgICBwdWJsaWMgc3RhdGljIGdldEJ1aWxkZXIoKTogQnVpbGRlciB7XG4gICAgICAgICAgICByZXR1cm4gbmV3IEJ1aWxkZXIoKTtcbiAgICAgICAgfVxuXG4gICAgICAgIHB1YmxpYyBzdGF0aWMgb2ZUeXBlKHR5cGU6IHN0cmluZyk6IEJ1aWxkZXIge1xuICAgICAgICAgICAgY29uc3QgcWIgPSBuZXcgQnVpbGRlcigpO1xuICAgICAgICAgICAgcWIuX3R5cGUgPSB0eXBlO1xuICAgICAgICAgICAgcmV0dXJuIHFiO1xuICAgICAgICB9XG5cbiAgICAgICAgcHVibGljIGZvcm1hdChmb3JtYXQ6IFF1ZXJ5LkZvcm1hdCk6IEJ1aWxkZXIge1xuICAgICAgICAgICAgdGhpcy5fZm9ybWF0ID0gZm9ybWF0O1xuICAgICAgICAgICAgcmV0dXJuIHRoaXM7XG4gICAgICAgIH1cblxuICAgICAgICBwdWJsaWMgbGlua3MobGlua3M6IGJvb2xlYW4pOiBCdWlsZGVyIHtcbiAgICAgICAgICAgIHRoaXMuX2xpbmtzID0gbGlua3M7XG4gICAgICAgICAgICByZXR1cm4gdGhpcztcbiAgICAgICAgfVxuXG4gICAgICAgIHB1YmxpYyBwYWdlU2l6ZShwYWdlU2l6ZTogbnVtYmVyKTogQnVpbGRlciB7XG4gICAgICAgICAgICB0aGlzLl9wYWdlU2l6ZSA9IHBhZ2VTaXplO1xuICAgICAgICAgICAgcmV0dXJuIHRoaXM7XG4gICAgICAgIH1cblxuICAgICAgICBwdWJsaWMgZmllbGRzKC4uLmZpZWxkczogc3RyaW5nW10pOiBCdWlsZGVyIHtcbiAgICAgICAgICAgIHRoaXMuX2ZpZWxkcyA9IGZpZWxkcztcbiAgICAgICAgICAgIHJldHVybiB0aGlzO1xuICAgICAgICB9XG5cbiAgICAgICAgcHVibGljIGZpbHRlcihmaWx0ZXI6IHN0cmluZyk6IEJ1aWxkZXIge1xuICAgICAgICAgICAgdGhpcy5fZmlsdGVyID0gZmlsdGVyO1xuICAgICAgICAgICAgcmV0dXJuIHRoaXM7XG4gICAgICAgIH1cblxuICAgICAgICBwdWJsaWMgc29ydCguLi5zb3J0OiB7IGZpZWxkOiBzdHJpbmcsIHJldmVyc2U/OiBib29sZWFuIH1bXSk6IEJ1aWxkZXIge1xuICAgICAgICAgICAgdGhpcy5fc29ydCA9IHNvcnQ7XG4gICAgICAgICAgICByZXR1cm4gdGhpcztcbiAgICAgICAgfVxuXG4gICAgICAgIHB1YmxpYyBnZXQoKTogc3RyaW5nIHtcbiAgICAgICAgICAgIGxldCBxdWVyeSA9IGA/dHlwZT0ke3RoaXMuX3R5cGV9JmZvcm1hdD0ke3RoaXMuX2Zvcm1hdH0mbGlua3M9JHt0aGlzLl9saW5rc30mcGFnZVNpemU9JHt0aGlzLl9wYWdlU2l6ZX1gO1xuICAgICAgICAgICAgaWYgKHRoaXMuX2ZpZWxkcyAmJiB0aGlzLl9maWVsZHMubGVuZ3RoID4gMCkge1xuICAgICAgICAgICAgICAgIHF1ZXJ5ICs9IGAmZmllbGRzPSR7dGhpcy5fZmllbGRzLmpvaW4oJywnKX1gO1xuICAgICAgICAgICAgfVxuXG4gICAgICAgICAgICBpZiAodGhpcy5fZmlsdGVyKSB7XG4gICAgICAgICAgICAgICAgcXVlcnkgKz0gYCZmaWx0ZXI9JHt0aGlzLl9maWx0ZXJ9YDtcbiAgICAgICAgICAgIH1cblxuICAgICAgICAgICAgaWYgKHRoaXMuX3NvcnQpIHtcbiAgICAgICAgICAgICAgICB0aGlzLl9zb3J0LmZvckVhY2gocyA9PiB7XG4gICAgICAgICAgICAgICAgICAgIHF1ZXJ5ICs9IGAmJHtzLnJldmVyc2UgPyAnc29ydERlc2MnIDogJ3NvcnRBc2MnfT0ke3MuZmllbGR9YDtcbiAgICAgICAgICAgICAgICB9KTtcbiAgICAgICAgICAgIH1cblxuICAgICAgICAgICAgcmV0dXJuIHF1ZXJ5O1xuICAgICAgICB9XG5cbiAgICAgICAgcHVibGljIGdldENsb3VkQVBJKCk6IHN0cmluZyB7XG4gICAgICAgICAgICBsZXQgcXVlcnkgPSBgP3BhZ2VTaXplPSR7dGhpcy5fcGFnZVNpemV9YDtcblxuICAgICAgICAgICAgaWYgKHRoaXMuX2ZpbHRlcikge1xuICAgICAgICAgICAgICAgIHF1ZXJ5ICs9IGAmZmlsdGVyPSR7dGhpcy5fZmlsdGVyfWA7XG4gICAgICAgICAgICB9XG5cbiAgICAgICAgICAgIGlmICh0aGlzLl9zb3J0KSB7XG4gICAgICAgICAgICAgICAgdGhpcy5fc29ydC5mb3JFYWNoKHMgPT4ge1xuICAgICAgICAgICAgICAgICAgICBxdWVyeSArPSBgJiR7cy5yZXZlcnNlID8gJ3NvcnREZXNjJyA6ICdzb3J0QXNjJ309JHtzLmZpZWxkfWA7XG4gICAgICAgICAgICAgICAgfSk7XG4gICAgICAgICAgICB9XG5cbiAgICAgICAgICAgIHJldHVybiBxdWVyeTtcbiAgICAgICAgfVxuICAgIH1cblxuICAgIGV4cG9ydCBjbGFzcyBGb3JtYXQge1xuICAgICAgICBzdGF0aWMgcmVhZG9ubHkgSURfUkVDT1JEUzogc3RyaW5nID0gJ2lkcmVjb3Jkcyc7XG4gICAgICAgIHN0YXRpYyByZWFkb25seSBSRUNPUkRTOiBzdHJpbmcgPSAncmVjb3Jkcyc7XG4gICAgICAgIHN0YXRpYyByZWFkb25seSBSRUZFUkVOQ0VTOiBzdHJpbmcgPSAncmVmZXJlbmNlcyc7XG4gICAgfVxufVxuIl19