@theseam/ui-common 0.2.9

package/esm2015/utils/wait-on-condition-async.js

@@ -0,0 +1,33 @@
+import { __awaiter } from "tslib";
+export function waitOnConditionAsync(condition, timeoutDuration = -1, throwOnTimeout = true) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const timeStart = new Date();
+        const _waitFunc = (callback) => {
+            let conditionSuccess = false;
+            if (condition()) {
+                callback(true);
+                conditionSuccess = true;
+            }
+            if (!conditionSuccess) {
+                const timeNow = new Date();
+                const duration = timeNow - timeStart;
+                if (timeoutDuration > -1 && duration > timeoutDuration) {
+                    if (throwOnTimeout) {
+                        throw new Error('Timed out waiting on condition.');
+                    }
+                    else {
+                        callback(false);
+                    }
+                }
+                setTimeout(() => { _waitFunc(callback); }, 30);
+            }
+        };
+        return new Promise((resolve, reject) => {
+            const fn = (b) => {
+                resolve(b);
+            };
+            _waitFunc(fn);
+        });
+    });
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/utils/wrap-into-observable.js

@@ -0,0 +1,8 @@
+import { from, isObservable } from 'rxjs';
+export function wrapIntoObservable(value) {
+    if (isObservable(value)) {
+        return value;
+    }
+    return from(Promise.resolve(value));
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoid3JhcC1pbnRvLW9ic2VydmFibGUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9wcm9qZWN0cy91aS1jb21tb24vdXRpbHMvd3JhcC1pbnRvLW9ic2VydmFibGUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLElBQUksRUFBRSxZQUFZLEVBQWMsTUFBTSxNQUFNLENBQUE7QUFFckQsTUFBTSxVQUFVLGtCQUFrQixDQUFJLEtBQW9DO0lBQ3hFLElBQUksWUFBWSxDQUFDLEtBQUssQ0FBQyxFQUFFO1FBQ3ZCLE9BQU8sS0FBSyxDQUFBO0tBQ2I7SUFFRCxPQUFPLElBQUksQ0FBQyxPQUFPLENBQUMsT0FBTyxDQUFDLEtBQUssQ0FBQyxDQUFDLENBQUE7QUFDckMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IGZyb20sIGlzT2JzZXJ2YWJsZSwgT2JzZXJ2YWJsZSB9IGZyb20gJ3J4anMnXG5cbmV4cG9ydCBmdW5jdGlvbiB3cmFwSW50b09ic2VydmFibGU8VD4odmFsdWU6IFQgfCBQcm9taXNlPFQ+fCBPYnNlcnZhYmxlPFQ+KTogT2JzZXJ2YWJsZTxUPiB7XG4gIGlmIChpc09ic2VydmFibGUodmFsdWUpKSB7XG4gICAgcmV0dXJuIHZhbHVlXG4gIH1cblxuICByZXR1cm4gZnJvbShQcm9taXNlLnJlc29sdmUodmFsdWUpKVxufVxuIl19

package/esm2015/validators/decimal.validator.js

@@ -0,0 +1,25 @@
+import { Validators } from '@angular/forms';
+import { isEmptyInputValue, isNumeric } from '@theseam/ui-common/utils';
+export const DECIMAL_REGEX = /^([-+]{1})?\d*(\.\d*)?$/;
+function _decimalValidator() {
+    return (control) => {
+        if (isEmptyInputValue(control.value)) {
+            return null; // don't validate empty values to allow optional controls
+        }
+        const isDecimal = !Array.isArray(control.value) &&
+            isNumeric(control.value) &&
+            (Validators.pattern(DECIMAL_REGEX)(control) === null);
+        if (!isDecimal) {
+            return { 'decimal': { 'reason': 'Must be valid decimal number.' } };
+        }
+        return null;
+    };
+}
+/**
+ * Validates control value is a valid decimal number.
+ *
+ * NOTE: This does not allow any js valid decimal number. It only accepts them
+ * in a format expected by our backend.
+ */
+export const decimalValidator = _decimalValidator();
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/validators/email-exists.validator.js

@@ -0,0 +1,18 @@
+import { isObservable } from 'rxjs';
+import { map } from 'rxjs/operators';
+/**
+ * Validates that an email already exists.
+ */
+export function emailExistsValidator(emailExists) {
+    return (control) => {
+        const validationResult = (exists) => {
+            return exists === false ? null : { 'emailExists': {} };
+        };
+        const fnRes = emailExists(control.value);
+        if (isObservable(fnRes)) {
+            return fnRes.pipe(map(validationResult));
+        }
+        return Promise.resolve(fnRes).then(validationResult);
+    };
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZW1haWwtZXhpc3RzLnZhbGlkYXRvci5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3Byb2plY3RzL3VpLWNvbW1vbi92YWxpZGF0b3JzL2VtYWlsLWV4aXN0cy52YWxpZGF0b3IudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQ0EsT0FBTyxFQUFFLFlBQVksRUFBYyxNQUFNLE1BQU0sQ0FBQTtBQUMvQyxPQUFPLEVBQUUsR0FBRyxFQUFFLE1BQU0sZ0JBQWdCLENBQUE7QUFFcEM7O0dBRUc7QUFDSCxNQUFNLFVBQVUsb0JBQW9CLENBQ2xDLFdBQWdGO0lBRWhGLE9BQU8sQ0FBQyxPQUFvQixFQUFFLEVBQUU7UUFDOUIsTUFBTSxnQkFBZ0IsR0FBRyxDQUFDLE1BQWUsRUFBRSxFQUFFO1lBQzNDLE9BQU8sTUFBTSxLQUFLLEtBQUssQ0FBQyxDQUFDLENBQUMsSUFBSSxDQUFDLENBQUMsQ0FBQyxFQUFFLGFBQWEsRUFBRSxFQUFFLEVBQUUsQ0FBQTtRQUN4RCxDQUFDLENBQUE7UUFFRCxNQUFNLEtBQUssR0FBRyxXQUFXLENBQUMsT0FBTyxDQUFDLEtBQUssQ0FBQyxDQUFBO1FBQ3hDLElBQUksWUFBWSxDQUFDLEtBQUssQ0FBQyxFQUFFO1lBQ3ZCLE9BQU8sS0FBSyxDQUFDLElBQUksQ0FBQyxHQUFHLENBQUMsZ0JBQWdCLENBQUMsQ0FBQyxDQUFBO1NBQ3pDO1FBQ0QsT0FBTyxPQUFPLENBQUMsT0FBTyxDQUFDLEtBQUssQ0FBQyxDQUFDLElBQUksQ0FBQyxnQkFBZ0IsQ0FBQyxDQUFBO0lBQ3RELENBQUMsQ0FBQTtBQUNILENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBGb3JtQ29udHJvbCB9IGZyb20gJ0Bhbmd1bGFyL2Zvcm1zJ1xuaW1wb3J0IHsgaXNPYnNlcnZhYmxlLCBPYnNlcnZhYmxlIH0gZnJvbSAncnhqcydcbmltcG9ydCB7IG1hcCB9IGZyb20gJ3J4anMvb3BlcmF0b3JzJ1xuXG4vKipcbiAqIFZhbGlkYXRlcyB0aGF0IGFuIGVtYWlsIGFscmVhZHkgZXhpc3RzLlxuICovXG5leHBvcnQgZnVuY3Rpb24gZW1haWxFeGlzdHNWYWxpZGF0b3IoXG4gIGVtYWlsRXhpc3RzOiAoZW1haWw6IHN0cmluZykgPT4gUHJvbWlzZTxib29sZWFuPiB8IE9ic2VydmFibGU8Ym9vbGVhbj4gfCBib29sZWFuXG4pIHtcbiAgcmV0dXJuIChjb250cm9sOiBGb3JtQ29udHJvbCkgPT4ge1xuICAgIGNvbnN0IHZhbGlkYXRpb25SZXN1bHQgPSAoZXhpc3RzOiBib29sZWFuKSA9PiB7XG4gICAgICByZXR1cm4gZXhpc3RzID09PSBmYWxzZSA/IG51bGwgOiB7ICdlbWFpbEV4aXN0cyc6IHt9IH1cbiAgICB9XG5cbiAgICBjb25zdCBmblJlcyA9IGVtYWlsRXhpc3RzKGNvbnRyb2wudmFsdWUpXG4gICAgaWYgKGlzT2JzZXJ2YWJsZShmblJlcykpIHtcbiAgICAgIHJldHVybiBmblJlcy5waXBlKG1hcCh2YWxpZGF0aW9uUmVzdWx0KSlcbiAgICB9XG4gICAgcmV0dXJuIFByb21pc2UucmVzb2x2ZShmblJlcykudGhlbih2YWxpZGF0aW9uUmVzdWx0KVxuICB9XG59XG4iXX0=

package/esm2015/validators/integer.validator.js

@@ -0,0 +1,25 @@
+import { Validators } from '@angular/forms';
+import { isEmptyInputValue, isNumeric } from '@theseam/ui-common/utils';
+export const INTEGER_REGEX = /^([-+]{1})?[0-9]*$/;
+function _integerValidator() {
+    return (control) => {
+        if (isEmptyInputValue(control.value)) {
+            return null; // don't validate empty values to allow optional controls
+        }
+        const isInteger = !Array.isArray(control.value) &&
+            isNumeric(control.value) &&
+            (Validators.pattern(INTEGER_REGEX)(control) === null);
+        if (!isInteger) {
+            return { 'integer': { 'reason': 'Must be valid integer.' } };
+        }
+        return null;
+    };
+}
+/**
+ * Validates control value is a valid integer number.
+ *
+ * NOTE: This does not allow any js valid integer number. It only accepts them
+ * in a format expected by our backend.
+ */
+export const integerValidator = _integerValidator();
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW50ZWdlci52YWxpZGF0b3IuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9wcm9qZWN0cy91aS1jb21tb24vdmFsaWRhdG9ycy9pbnRlZ2VyLnZhbGlkYXRvci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQWdDLFVBQVUsRUFBRSxNQUFNLGdCQUFnQixDQUFBO0FBRXpFLE9BQU8sRUFBRSxpQkFBaUIsRUFBRSxTQUFTLEVBQUUsTUFBTSwwQkFBMEIsQ0FBQTtBQUV2RSxNQUFNLENBQUMsTUFBTSxhQUFhLEdBQUcsb0JBQW9CLENBQUE7QUFFakQsU0FBUyxpQkFBaUI7SUFDeEIsT0FBTyxDQUFDLE9BQXdCLEVBQUUsRUFBRTtRQUNsQyxJQUFJLGlCQUFpQixDQUFDLE9BQU8sQ0FBQyxLQUFLLENBQUMsRUFBRTtZQUNwQyxPQUFPLElBQUksQ0FBQSxDQUFDLHlEQUF5RDtTQUN0RTtRQUVELE1BQU0sU0FBUyxHQUNiLENBQUMsS0FBSyxDQUFDLE9BQU8sQ0FBQyxPQUFPLENBQUMsS0FBSyxDQUFDO1lBQzdCLFNBQVMsQ0FBQyxPQUFPLENBQUMsS0FBSyxDQUFDO1lBQ3hCLENBQUMsVUFBVSxDQUFDLE9BQU8sQ0FBQyxhQUFhLENBQUMsQ0FBQyxPQUFPLENBQUMsS0FBSyxJQUFJLENBQUMsQ0FBQTtRQUV2RCxJQUFJLENBQUMsU0FBUyxFQUFFO1lBQ2QsT0FBTyxFQUFFLFNBQVMsRUFBRSxFQUFFLFFBQVEsRUFBRSx3QkFBd0IsRUFBRSxFQUFFLENBQUE7U0FDN0Q7UUFDRCxPQUFPLElBQUksQ0FBQTtJQUNiLENBQUMsQ0FBQTtBQUNILENBQUM7QUFFRDs7Ozs7R0FLRztBQUNILE1BQU0sQ0FBQyxNQUFNLGdCQUFnQixHQUFnQixpQkFBaUIsRUFBRSxDQUFBIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgQWJzdHJhY3RDb250cm9sLCBWYWxpZGF0b3JGbiwgVmFsaWRhdG9ycyB9IGZyb20gJ0Bhbmd1bGFyL2Zvcm1zJ1xuXG5pbXBvcnQgeyBpc0VtcHR5SW5wdXRWYWx1ZSwgaXNOdW1lcmljIH0gZnJvbSAnQHRoZXNlYW0vdWktY29tbW9uL3V0aWxzJ1xuXG5leHBvcnQgY29uc3QgSU5URUdFUl9SRUdFWCA9IC9eKFstK117MX0pP1swLTldKiQvXG5cbmZ1bmN0aW9uIF9pbnRlZ2VyVmFsaWRhdG9yKCk6IFZhbGlkYXRvckZuIHtcbiAgcmV0dXJuIChjb250cm9sOiBBYnN0cmFjdENvbnRyb2wpID0+IHtcbiAgICBpZiAoaXNFbXB0eUlucHV0VmFsdWUoY29udHJvbC52YWx1ZSkpIHtcbiAgICAgIHJldHVybiBudWxsIC8vIGRvbid0IHZhbGlkYXRlIGVtcHR5IHZhbHVlcyB0byBhbGxvdyBvcHRpb25hbCBjb250cm9sc1xuICAgIH1cblxuICAgIGNvbnN0IGlzSW50ZWdlciA9XG4gICAgICAhQXJyYXkuaXNBcnJheShjb250cm9sLnZhbHVlKSAmJlxuICAgICAgaXNOdW1lcmljKGNvbnRyb2wudmFsdWUpICYmXG4gICAgICAoVmFsaWRhdG9ycy5wYXR0ZXJuKElOVEVHRVJfUkVHRVgpKGNvbnRyb2wpID09PSBudWxsKVxuXG4gICAgaWYgKCFpc0ludGVnZXIpIHtcbiAgICAgIHJldHVybiB7ICdpbnRlZ2VyJzogeyAncmVhc29uJzogJ011c3QgYmUgdmFsaWQgaW50ZWdlci4nIH0gfVxuICAgIH1cbiAgICByZXR1cm4gbnVsbFxuICB9XG59XG5cbi8qKlxuICogVmFsaWRhdGVzIGNvbnRyb2wgdmFsdWUgaXMgYSB2YWxpZCBpbnRlZ2VyIG51bWJlci5cbiAqXG4gKiBOT1RFOiBUaGlzIGRvZXMgbm90IGFsbG93IGFueSBqcyB2YWxpZCBpbnRlZ2VyIG51bWJlci4gSXQgb25seSBhY2NlcHRzIHRoZW1cbiAqIGluIGEgZm9ybWF0IGV4cGVjdGVkIGJ5IG91ciBiYWNrZW5kLlxuICovXG5leHBvcnQgY29uc3QgaW50ZWdlclZhbGlkYXRvcjogVmFsaWRhdG9yRm4gPSBfaW50ZWdlclZhbGlkYXRvcigpXG4iXX0=

package/esm2015/validators/phone-length.validator.js

@@ -0,0 +1,8 @@
+/**
+ * Validates that a value is a valid phone number length.
+ */
+export function phoneLengthValidator(control) {
+    return control.value.length === 0 || (control.value.length <= 18 && control.value.length >= 7)
+        ? null : { 'phoneLength': {} };
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGhvbmUtbGVuZ3RoLnZhbGlkYXRvci5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3Byb2plY3RzL3VpLWNvbW1vbi92YWxpZGF0b3JzL3Bob25lLWxlbmd0aC52YWxpZGF0b3IudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBRUE7O0dBRUc7QUFDSCxNQUFNLFVBQVUsb0JBQW9CLENBQUMsT0FBb0I7SUFDdkQsT0FBTyxPQUFPLENBQUMsS0FBSyxDQUFDLE1BQU0sS0FBSyxDQUFDLElBQUksQ0FBQyxPQUFPLENBQUMsS0FBSyxDQUFDLE1BQU0sSUFBSSxFQUFFLElBQUksT0FBTyxDQUFDLEtBQUssQ0FBQyxNQUFNLElBQUksQ0FBQyxDQUFDO1FBQzVGLENBQUMsQ0FBQyxJQUFJLENBQUMsQ0FBQyxDQUFDLEVBQUUsYUFBYSxFQUFFLEVBQUUsRUFBRSxDQUFBO0FBQ2xDLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBGb3JtQ29udHJvbCB9IGZyb20gJ0Bhbmd1bGFyL2Zvcm1zJ1xuXG4vKipcbiAqIFZhbGlkYXRlcyB0aGF0IGEgdmFsdWUgaXMgYSB2YWxpZCBwaG9uZSBudW1iZXIgbGVuZ3RoLlxuICovXG5leHBvcnQgZnVuY3Rpb24gcGhvbmVMZW5ndGhWYWxpZGF0b3IoY29udHJvbDogRm9ybUNvbnRyb2wpIHtcbiAgcmV0dXJuIGNvbnRyb2wudmFsdWUubGVuZ3RoID09PSAwIHx8IChjb250cm9sLnZhbHVlLmxlbmd0aCA8PSAxOCAmJiBjb250cm9sLnZhbHVlLmxlbmd0aCA+PSA3KVxuICAgID8gbnVsbCA6IHsgJ3Bob25lTGVuZ3RoJzoge30gfVxufVxuIl19

package/esm2015/validators/public-api.js

@@ -0,0 +1,6 @@
+export * from './tax-id.validator';
+export * from './email-exists.validator';
+export * from './phone-length.validator';
+export * from './decimal.validator';
+export * from './integer.validator';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3Byb2plY3RzL3VpLWNvbW1vbi92YWxpZGF0b3JzL3B1YmxpYy1hcGkudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxvQkFBb0IsQ0FBQTtBQUNsQyxjQUFjLDBCQUEwQixDQUFBO0FBQ3hDLGNBQWMsMEJBQTBCLENBQUE7QUFDeEMsY0FBYyxxQkFBcUIsQ0FBQTtBQUNuQyxjQUFjLHFCQUFxQixDQUFBIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi90YXgtaWQudmFsaWRhdG9yJ1xuZXhwb3J0ICogZnJvbSAnLi9lbWFpbC1leGlzdHMudmFsaWRhdG9yJ1xuZXhwb3J0ICogZnJvbSAnLi9waG9uZS1sZW5ndGgudmFsaWRhdG9yJ1xuZXhwb3J0ICogZnJvbSAnLi9kZWNpbWFsLnZhbGlkYXRvcidcbmV4cG9ydCAqIGZyb20gJy4vaW50ZWdlci52YWxpZGF0b3InXG4iXX0=

package/esm2015/validators/tax-id.validator.js

@@ -0,0 +1,13 @@
+/**
+ * Validates that value matches on of the following:
+ *  ''             // empty string
+ *  'xxxxxxxxx'    // 'x' is a number
+ *  'xx-xxxxxxx'   // 'x' is a number
+ *  'xxx-xx-xxxx'  // 'x' is a number
+ */
+export function taxIdValidator(control) {
+    const isValid = /^$|^\d{9}$|^\d{2}-\d{7}$|^\d{3}-\d{2}-\d{4}$/.test(control.value);
+    return isValid
+        ? null : { taxId: {} };
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidGF4LWlkLnZhbGlkYXRvci5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3Byb2plY3RzL3VpLWNvbW1vbi92YWxpZGF0b3JzL3RheC1pZC52YWxpZGF0b3IudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBRUE7Ozs7OztHQU1HO0FBQ0gsTUFBTSxVQUFVLGNBQWMsQ0FBQyxPQUFvQjtJQUNqRCxNQUFNLE9BQU8sR0FBRyw4Q0FBOEMsQ0FBQyxJQUFJLENBQUMsT0FBTyxDQUFDLEtBQUssQ0FBQyxDQUFBO0lBQ2xGLE9BQU8sT0FBTztRQUNaLENBQUMsQ0FBQyxJQUFJLENBQUMsQ0FBQyxDQUFDLEVBQUUsS0FBSyxFQUFFLEVBQUUsRUFBRSxDQUFBO0FBQzFCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBGb3JtQ29udHJvbCB9IGZyb20gJ0Bhbmd1bGFyL2Zvcm1zJ1xuXG4vKipcbiAqIFZhbGlkYXRlcyB0aGF0IHZhbHVlIG1hdGNoZXMgb24gb2YgdGhlIGZvbGxvd2luZzpcbiAqICAnJyAgICAgICAgICAgICAvLyBlbXB0eSBzdHJpbmdcbiAqICAneHh4eHh4eHh4JyAgICAvLyAneCcgaXMgYSBudW1iZXJcbiAqICAneHgteHh4eHh4eCcgICAvLyAneCcgaXMgYSBudW1iZXJcbiAqICAneHh4LXh4LXh4eHgnICAvLyAneCcgaXMgYSBudW1iZXJcbiAqL1xuZXhwb3J0IGZ1bmN0aW9uIHRheElkVmFsaWRhdG9yKGNvbnRyb2w6IEZvcm1Db250cm9sKSB7XG4gIGNvbnN0IGlzVmFsaWQgPSAvXiR8XlxcZHs5fSR8XlxcZHsyfS1cXGR7N30kfF5cXGR7M30tXFxkezJ9LVxcZHs0fSQvLnRlc3QoY29udHJvbC52YWx1ZSlcbiAgcmV0dXJuIGlzVmFsaWRcbiAgICA/IG51bGwgOiB7IHRheElkOiB7fSB9XG59XG4iXX0=

package/esm2015/validators/theseam-ui-common-validators.js

@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+export * from './public-api';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidGhlc2VhbS11aS1jb21tb24tdmFsaWRhdG9ycy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3Byb2plY3RzL3VpLWNvbW1vbi92YWxpZGF0b3JzL3RoZXNlYW0tdWktY29tbW9uLXZhbGlkYXRvcnMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7O0dBRUc7QUFFSCxjQUFjLGNBQWMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogR2VuZXJhdGVkIGJ1bmRsZSBpbmRleC4gRG8gbm90IGVkaXQuXG4gKi9cblxuZXhwb3J0ICogZnJvbSAnLi9wdWJsaWMtYXBpJztcbiJdfQ==

package/esm2015/viewers/pdf-viewer/index.js

@@ -0,0 +1,4 @@
+export * from './pdf-page/pdf-page.component';
+export * from './pdf-viewer.component';
+export * from './pdf-viewer.module';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy91aS1jb21tb24vdmlld2Vycy9wZGYtdmlld2VyL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsK0JBQStCLENBQUE7QUFDN0MsY0FBYyx3QkFBd0IsQ0FBQTtBQUN0QyxjQUFjLHFCQUFxQixDQUFBIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9wZGYtcGFnZS9wZGYtcGFnZS5jb21wb25lbnQnXG5leHBvcnQgKiBmcm9tICcuL3BkZi12aWV3ZXIuY29tcG9uZW50J1xuZXhwb3J0ICogZnJvbSAnLi9wZGYtdmlld2VyLm1vZHVsZSdcbiJdfQ==

package/esm2015/viewers/pdf-viewer/pdf-page/pdf-page.component.js

@@ -0,0 +1,134 @@
+import { __awaiter, __decorate } from "tslib";
+import { Component, HostBinding, Input, ViewChild } from '@angular/core';
+import { from, Subject } from 'rxjs';
+import { auditTime, switchMap, takeUntil } from 'rxjs/operators';
+import { InputBoolean } from '@theseam/ui-common/core';
+import { waitOnConditionAsync } from '@theseam/ui-common/utils';
+export class TheSeamPdfPageComponent {
+    constructor() {
+        this._ngUnsubscribe = new Subject();
+        this.shadow = false;
+        /**
+         * Canvas will responsively scale and rerender if scaled more than
+         * `renderUpdateThreshold` pixels.
+         */
+        this.responsive = false;
+        /**
+         * The canvas will be rerendered if the canvas size changes by this many
+         * pixels from the last render.
+         *
+         * To make the canvas responsive using only the initial size for its render
+         * set the threshold to `-1`. You can still trigger a rerender by calling the
+         * `render()` method.
+         *
+         * NOTE: Only used when `responsive` is `true`.
+         */
+        this.renderUpdateThreshold = 100;
+        this.rendering = false;
+        this._renderRequestSubject = new Subject();
+        this._render$ = this._renderRequestSubject.pipe(takeUntil(this._ngUnsubscribe), auditTime(500), switchMap(_ => from(waitOnConditionAsync(() => this.rendering === false, 30 * 1000))), switchMap(_ => from(this._render())));
+    }
+    get page() { return this._page; }
+    set page(value) {
+        this._page = value;
+        setTimeout(() => { this.render(); });
+    }
+    get _shadow() { return this.shadow; }
+    ngOnDestroy() {
+        this._ngUnsubscribe.next();
+        this._ngUnsubscribe.complete();
+    }
+    ngAfterViewInit() {
+        this._render$.subscribe();
+        this.render();
+    }
+    render() {
+        this._renderRequestSubject.next();
+    }
+    _render() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.pdfContainer || !this.pdfCanvas) {
+                return;
+            }
+            try {
+                const w = this.pdfContainer.nativeElement.clientWidth;
+                const desiredWidth = w;
+                const viewport = this.page.getViewport({ scale: 1 });
+                const scale = desiredWidth / viewport.width;
+                const scaledViewport = this.page.getViewport({ scale });
+                // Prepare canvas using PDF page dimensions
+                const canvas = this.pdfCanvas.nativeElement;
+                const context = canvas.getContext('2d');
+                canvas.height = scaledViewport.height;
+                canvas.width = scaledViewport.width;
+                canvas.style.height = `${scaledViewport.height}px`;
+                canvas.style.width = `${scaledViewport.width}px`;
+                // Render PDF page into canvas context
+                const renderContext = {
+                    canvasContext: context,
+                    viewport: scaledViewport
+                };
+                const renderTask = yield this.page.render(renderContext).promise;
+                // TODO: Allow canceling instead of only waiting
+                // await renderTask.cancel()
+                this.rendering = false;
+                if (this.responsive) {
+                    canvas.style.width = '100%';
+                    canvas.style.height = '100%';
+                }
+            }
+            catch (err) {
+                // PDF loading error
+                console.error(err);
+            }
+        });
+    }
+    onResized() {
+        if (!this.responsive || this.renderUpdateThreshold === -1) {
+            return;
+        }
+        if (!this.pdfContainer || !this.pdfCanvas) {
+            return;
+        }
+        const containerRect = this.pdfContainer.nativeElement.getBoundingClientRect();
+        const pdfWidth = this.pdfCanvas.nativeElement.width;
+        const pdfHeight = this.pdfCanvas.nativeElement.height;
+        const wDiff = Math.abs(containerRect.width - pdfWidth);
+        const hDiff = Math.abs(containerRect.height - pdfHeight);
+        if (wDiff > this.renderUpdateThreshold || hDiff > this.renderUpdateThreshold) {
+            this.render();
+        }
+    }
+}
+TheSeamPdfPageComponent.decorators = [
+    { type: Component, args: [{
+                selector: 'seam-pdf-page',
+                template: `
+  <div #pdfContainer
+    (seamElemResized)="onResized()">
+    <canvas #pdfCanvas></canvas>
+  </div>
+  `,
+                styles: [`
+    :host { display: block; }
+    canvas { display: block; }
+  `]
+            },] }
+];
+TheSeamPdfPageComponent.ctorParameters = () => [];
+TheSeamPdfPageComponent.propDecorators = {
+    page: [{ type: Input }],
+    shadow: [{ type: Input }],
+    _shadow: [{ type: HostBinding, args: ['class.shadow',] }],
+    pdfContainer: [{ type: ViewChild, args: ['pdfContainer', { static: true },] }],
+    pdfCanvas: [{ type: ViewChild, args: ['pdfCanvas', { static: true },] }],
+    responsive: [{ type: Input }],
+    renderUpdateThreshold: [{ type: Input }]
+};
+__decorate([
+    InputBoolean()
+], TheSeamPdfPageComponent.prototype, "shadow", void 0);
+__decorate([
+    InputBoolean()
+], TheSeamPdfPageComponent.prototype, "responsive", void 0);
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"pdf-page.component.js","sourceRoot":"","sources":["../../../../../../projects/ui-common/viewers/pdf-viewer/pdf-page/pdf-page.component.ts"],"names":[],"mappings":"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","sourcesContent":["import { BooleanInput } from '@angular/cdk/coercion'\nimport { AfterViewInit, Component, ElementRef, HostBinding, Input, OnDestroy, ViewChild } from '@angular/core'\nimport { from, Observable, Subject } from 'rxjs'\nimport { auditTime, switchMap, takeUntil } from 'rxjs/operators'\n\nimport { InputBoolean } from '@theseam/ui-common/core'\nimport { waitOnConditionAsync } from '@theseam/ui-common/utils'\n\n@Component({\n  selector: 'seam-pdf-page',\n  template: `\n  <div #pdfContainer\n    (seamElemResized)=\"onResized()\">\n    <canvas #pdfCanvas></canvas>\n  </div>\n  `,\n  styles: [`\n    :host { display: block; }\n    canvas { display: block; }\n  `]\n})\nexport class TheSeamPdfPageComponent implements OnDestroy, AfterViewInit {\n  static ngAcceptInputType_shadow: BooleanInput\n  static ngAcceptInputType_responsive: BooleanInput\n\n  private readonly _ngUnsubscribe = new Subject()\n\n  @Input()\n  public get page() { return this._page }\n  public set page(value) {\n    this._page = value\n    setTimeout(() => { this.render() })\n  }\n  private _page: any\n\n  @Input() @InputBoolean() shadow: boolean = false\n\n  @HostBinding('class.shadow') get _shadow() { return this.shadow }\n\n  @ViewChild('pdfContainer', { static: true }) pdfContainer?: ElementRef<HTMLDivElement>\n  @ViewChild('pdfCanvas', { static: true }) pdfCanvas?: ElementRef<HTMLCanvasElement>\n\n  /**\n   * Canvas will responsively scale and rerender if scaled more than\n   * `renderUpdateThreshold` pixels.\n   */\n  @Input() @InputBoolean() responsive = false\n\n  /**\n   * The canvas will be rerendered if the canvas size changes by this many\n   * pixels from the last render.\n   *\n   * To make the canvas responsive using only the initial size for its render\n   * set the threshold to `-1`. You can still trigger a rerender by calling the\n   * `render()` method.\n   *\n   * NOTE: Only used when `responsive` is `true`.\n   */\n  @Input() renderUpdateThreshold = 100\n\n  public rendering = false\n\n  private _renderRequestSubject = new Subject<void>()\n\n  private _render$: Observable<void>\n\n  constructor() {\n    this._render$ = this._renderRequestSubject.pipe(\n      takeUntil(this._ngUnsubscribe),\n      auditTime(500),\n      switchMap(_ => from(waitOnConditionAsync(() => this.rendering === false, 30 * 1000))),\n      switchMap(_ => from(this._render()))\n    )\n  }\n\n  ngOnDestroy() {\n    this._ngUnsubscribe.next()\n    this._ngUnsubscribe.complete()\n  }\n\n  ngAfterViewInit() {\n    this._render$.subscribe()\n    this.render()\n  }\n\n  public render() {\n    this._renderRequestSubject.next()\n  }\n\n  private async _render() {\n    if (!this.pdfContainer || !this.pdfCanvas) {\n      return\n    }\n\n    try {\n      const w = this.pdfContainer.nativeElement.clientWidth\n      const desiredWidth = w\n      const viewport = this.page.getViewport({ scale: 1 })\n      const scale = desiredWidth / viewport.width\n      const scaledViewport = this.page.getViewport({ scale })\n\n      // Prepare canvas using PDF page dimensions\n      const canvas: HTMLCanvasElement = this.pdfCanvas.nativeElement\n      const context = canvas.getContext('2d')\n      canvas.height = scaledViewport.height\n      canvas.width = scaledViewport.width\n      canvas.style.height = `${scaledViewport.height}px`\n      canvas.style.width = `${scaledViewport.width}px`\n\n      // Render PDF page into canvas context\n      const renderContext = {\n        canvasContext: context,\n        viewport: scaledViewport\n      }\n\n      const renderTask = await this.page.render(renderContext).promise\n\n      // TODO: Allow canceling instead of only waiting\n      // await renderTask.cancel()\n      this.rendering = false\n      if (this.responsive) {\n        canvas.style.width = '100%'\n        canvas.style.height = '100%'\n      }\n    } catch (err) {\n      // PDF loading error\n      console.error(err)\n    }\n  }\n\n  onResized() {\n    if (!this.responsive || this.renderUpdateThreshold === -1) { return }\n\n    if (!this.pdfContainer || !this.pdfCanvas) {\n      return\n    }\n\n    const containerRect = this.pdfContainer.nativeElement.getBoundingClientRect()\n    const pdfWidth = this.pdfCanvas.nativeElement.width\n    const pdfHeight = this.pdfCanvas.nativeElement.height\n    const wDiff = Math.abs(containerRect.width - pdfWidth)\n    const hDiff = Math.abs(containerRect.height - pdfHeight)\n    if (wDiff > this.renderUpdateThreshold || hDiff > this.renderUpdateThreshold) {\n      this.render()\n    }\n\n  }\n\n}\n"]}

package/esm2015/viewers/pdf-viewer/pdf-renderer.service.js

@@ -0,0 +1,27 @@
+import { Injectable } from '@angular/core';
+import { from } from 'rxjs';
+import { shareReplay, switchMap, tap } from 'rxjs/operators';
+import { wrapIntoObservable } from '@theseam/ui-common/utils';
+import * as i0 from "@angular/core";
+export class PdfRendererService {
+    constructor() {
+        const pdfjsImport = wrapIntoObservable(import('pdfjs-dist/legacy/build/pdf'));
+        this._pdfjs$ = pdfjsImport.pipe(tap((pdfJs) => {
+            if (!pdfJs.GlobalWorkerOptions.workerSrc) {
+                // tslint:disable-next-line:max-line-length
+                pdfJs.GlobalWorkerOptions.workerSrc = `https://cdnjs.cloudflare.com/ajax/libs/pdf.js/${pdfJs.version}/pdf.worker.min.js`;
+            }
+        }), shareReplay({ bufferSize: 1, refCount: true }));
+    }
+    getDocument(url) {
+        return from(fetch(url)).pipe(switchMap(v => this._pdfjs$.pipe(switchMap(pdfjs => pdfjs.getDocument(v).promise))));
+    }
+}
+PdfRendererService.ɵprov = i0.ɵɵdefineInjectable({ factory: function PdfRendererService_Factory() { return new PdfRendererService(); }, token: PdfRendererService, providedIn: "root" });
+PdfRendererService.decorators = [
+    { type: Injectable, args: [{
+                providedIn: 'root'
+            },] }
+];
+PdfRendererService.ctorParameters = () => [];
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/viewers/pdf-viewer/pdf-viewer.component.js

@@ -0,0 +1,149 @@
+import { __decorate } from "tslib";
+import { coerceArray, coerceNumberProperty } from '@angular/cdk/coercion';
+import { Component, Input } from '@angular/core';
+import { BehaviorSubject, from, of, ReplaySubject } from 'rxjs';
+import { map, switchMap } from 'rxjs/operators';
+import { InputBoolean } from '@theseam/ui-common/core';
+import { PdfRendererService } from './pdf-renderer.service';
+export class TheSeamPdfViewerComponent {
+    constructor(_pdfRenderer) {
+        this._pdfRenderer = _pdfRenderer;
+        this.shadow = false;
+        /**
+         * Canvas will responsively scale and rerender if scaled more than
+         * `renderUpdateThreshold` pixels.
+         */
+        this.responsive = false;
+        this._renderUpdateThreshold = 100;
+        this._pageRange = [];
+        this._pageNumber = -1;
+        this._pageNumbers = [];
+        this._documentSubject = new ReplaySubject(1);
+        /**
+         * Undefined means all a pages
+         */
+        this._pageNumbersSubject = new BehaviorSubject(undefined);
+        this.document$ = this._documentSubject.asObservable().pipe(switchMap(url => {
+            if (!url) {
+                return of();
+            }
+            return this._pdfRenderer.getDocument(url);
+        }));
+        const pageNumbers$ = this._pageNumbersSubject.asObservable();
+        this.pages$ = this.document$.pipe(switchMap(doc => pageNumbers$.pipe(map(pageNumbers => {
+            const pages = [];
+            for (let i = 0; i < doc.numPages; i++) {
+                if (!pageNumbers || pageNumbers.indexOf(i + 1) !== -1) {
+                    pages.push(from(doc.getPage(i + 1)));
+                }
+            }
+            return pages;
+        }))));
+    }
+    get pdfUrl() { return this._pdfUrl; }
+    set pdfUrl(value) {
+        this._pdfUrl = value;
+        this._documentSubject.next(value);
+    }
+    /**
+     * The canvas will be rerendered if the canvas size changes by this many
+     * pixels from the last render.
+     *
+     * To make the canvas responsive using only the initial size for its render
+     * set the threshold to `-1`. You can still trigger a rerender by calling the
+     * `render()` method.
+     *
+     * NOTE: Only used when `responsive` is `true`.
+     */
+    set renderUpdateThreshold(value) { this._renderUpdateThreshold = coerceNumberProperty(value); }
+    get renderUpdateThreshold() { return this._renderUpdateThreshold; }
+    /**
+     * Range of pages to render.
+     *
+     * Example(page 1 to page 3):
+     *  [pageRange]="[1,3]"
+     */
+    get pageRange() { return this._pageRange; }
+    set pageRange(value) {
+        this._pageRange = value;
+        if (!this._pageRange) {
+            this._pageNumbersSubject.next(undefined);
+        }
+        try {
+            const range = coerceArray(this._pageRange);
+            if (range.length !== 2) {
+                throw new Error('[pdf-viewer] Invalid Page Range. Range array must have two numbers only.');
+            }
+            if (range[0] > range[1]) {
+                throw new Error('[pdf-viewer] Invalid Page Range. Start of the range must be less than or equal to the end.');
+            }
+            const nums = [];
+            for (let i = range[0]; i <= range[1]; i++) {
+                nums.push(i);
+            }
+            this._pageNumbersSubject.next(nums);
+        }
+        catch (err) {
+            // TODO: Decide how to conveniently display these errors.
+            console.error(err);
+            this._pageNumbersSubject.next([]);
+        }
+    }
+    /**
+     * Render a specific page.
+     */
+    get pageNumber() { return this._pageNumber; }
+    set pageNumber(value) {
+        this._pageNumber = coerceNumberProperty(value, -1);
+        this._pageNumbersSubject.next(this._pageNumber === -1 ? undefined : [this._pageNumber]);
+    }
+    /**
+     * Specific page numbers to render.
+     */
+    get pageNumbers() { return this._pageNumbers; }
+    set pageNumbers(value) {
+        this._pageNumbers = value;
+        if (Array.isArray(this._pageNumbers)) {
+            this._pageNumbersSubject.next(this._pageNumbers);
+        }
+        else {
+            this._pageNumbersSubject.next(undefined);
+        }
+    }
+}
+TheSeamPdfViewerComponent.decorators = [
+    { type: Component, args: [{
+                selector: 'seam-pdf-viewer',
+                template: `
+  <ng-container *ngFor="let page of pages$ | async">
+    <seam-pdf-page
+      class="mb-2"
+      [page]="page | async"
+      [responsive]="responsive"
+      [shadow]="shadow"
+      [renderUpdateThreshold]="renderUpdateThreshold">
+    </seam-pdf-page>
+  </ng-container>
+  `,
+                styles: [`:host { display: block; }`]
+            },] }
+];
+TheSeamPdfViewerComponent.ctorParameters = () => [
+    { type: PdfRendererService }
+];
+TheSeamPdfViewerComponent.propDecorators = {
+    pdfUrl: [{ type: Input }],
+    shadow: [{ type: Input }],
+    responsive: [{ type: Input }],
+    renderUpdateThreshold: [{ type: Input }],
+    pageRange: [{ type: Input }],
+    pageNumber: [{ type: Input }],
+    pageNumbers: [{ type: Input }]
+};
+__decorate([
+    InputBoolean()
+], TheSeamPdfViewerComponent.prototype, "shadow", void 0);
+__decorate([
+    InputBoolean()
+], TheSeamPdfViewerComponent.prototype, "responsive", void 0);
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"pdf-viewer.component.js","sourceRoot":"","sources":["../../../../../projects/ui-common/viewers/pdf-viewer/pdf-viewer.component.ts"],"names":[],"mappings":"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","sourcesContent":["import { BooleanInput, coerceArray, coerceNumberProperty } from '@angular/cdk/coercion'\nimport { Component, Input } from '@angular/core'\nimport { BehaviorSubject, from, Observable, of, ReplaySubject } from 'rxjs'\nimport { map, shareReplay, switchMap, tap } from 'rxjs/operators'\n\nimport { InputBoolean } from '@theseam/ui-common/core'\nimport { wrapIntoObservable } from '@theseam/ui-common/utils'\n\nimport { PdfRendererService } from './pdf-renderer.service'\n\n@Component({\n  selector: 'seam-pdf-viewer',\n  template: `\n  <ng-container *ngFor=\"let page of pages$ | async\">\n    <seam-pdf-page\n      class=\"mb-2\"\n      [page]=\"page | async\"\n      [responsive]=\"responsive\"\n      [shadow]=\"shadow\"\n      [renderUpdateThreshold]=\"renderUpdateThreshold\">\n    </seam-pdf-page>\n  </ng-container>\n  `,\n  styles: [`:host { display: block; }`]\n})\nexport class TheSeamPdfViewerComponent {\n  static ngAcceptInputType_shadow: BooleanInput\n  static ngAcceptInputType_responsive: BooleanInput\n\n  @Input()\n  get pdfUrl(): string | undefined | null { return this._pdfUrl }\n  set pdfUrl(value: string | undefined | null) {\n    this._pdfUrl = value\n    this._documentSubject.next(value)\n  }\n  private _pdfUrl: string | undefined | null\n\n  @Input() @InputBoolean() shadow = false\n\n  /**\n   * Canvas will responsively scale and rerender if scaled more than\n   * `renderUpdateThreshold` pixels.\n   */\n  @Input() @InputBoolean() responsive = false\n\n  /**\n   * The canvas will be rerendered if the canvas size changes by this many\n   * pixels from the last render.\n   *\n   * To make the canvas responsive using only the initial size for its render\n   * set the threshold to `-1`. You can still trigger a rerender by calling the\n   * `render()` method.\n   *\n   * NOTE: Only used when `responsive` is `true`.\n   */\n  @Input()\n  set renderUpdateThreshold(value: number) { this._renderUpdateThreshold = coerceNumberProperty(value) }\n  get renderUpdateThreshold(): number { return this._renderUpdateThreshold }\n  private _renderUpdateThreshold: number = 100\n\n  /**\n   * Range of pages to render.\n   *\n   * Example(page 1 to page 3):\n   *  [pageRange]=\"[1,3]\"\n   */\n  @Input()\n  get pageRange(): number[] { return this._pageRange }\n  set pageRange(value: number[]) {\n    this._pageRange = value\n\n    if (!this._pageRange) {\n      this._pageNumbersSubject.next(undefined)\n    }\n\n    try {\n      const range = coerceArray(this._pageRange)\n      if (range.length !== 2) {\n        throw new Error('[pdf-viewer] Invalid Page Range. Range array must have two numbers only.')\n      }\n      if (range[0] > range[1]) {\n        throw new Error('[pdf-viewer] Invalid Page Range. Start of the range must be less than or equal to the end.')\n      }\n\n      const nums: number[] = []\n      for (let i = range[0]; i <= range[1]; i++) {\n        nums.push(i)\n      }\n      this._pageNumbersSubject.next(nums)\n    } catch (err) {\n      // TODO: Decide how to conveniently display these errors.\n      console.error(err)\n      this._pageNumbersSubject.next([])\n    }\n  }\n  private _pageRange: number[] = []\n\n  /**\n   * Render a specific page.\n   */\n  @Input()\n  get pageNumber(): number { return this._pageNumber }\n  set pageNumber(value: number) {\n    this._pageNumber = coerceNumberProperty(value, -1)\n    this._pageNumbersSubject.next(this._pageNumber === -1 ? undefined : [ this._pageNumber ])\n  }\n  private _pageNumber = -1\n\n  /**\n   * Specific page numbers to render.\n   */\n  @Input()\n  get pageNumbers(): number[] { return this._pageNumbers }\n  set pageNumbers(value: number[]) {\n    this._pageNumbers = value\n    if (Array.isArray(this._pageNumbers)) {\n      this._pageNumbersSubject.next(this._pageNumbers)\n    } else {\n      this._pageNumbersSubject.next(undefined)\n    }\n  }\n  private _pageNumbers: number[] = []\n\n  private _documentSubject = new ReplaySubject<any>(1)\n  public document$: Observable<any>\n  public pages$: Observable<any[]>\n\n  /**\n   * Undefined means all a pages\n   */\n  private _pageNumbersSubject = new BehaviorSubject<number[] | undefined>(undefined)\n\n  constructor(\n    private readonly _pdfRenderer: PdfRendererService\n  ) {\n    this.document$ = this._documentSubject.asObservable().pipe(\n      switchMap(url => {\n        if (!url) {\n          return of()\n        }\n        return this._pdfRenderer.getDocument(url)\n      })\n    )\n\n    const pageNumbers$ = this._pageNumbersSubject.asObservable()\n\n    this.pages$ = this.document$.pipe(\n      switchMap(doc => pageNumbers$.pipe(\n        map(pageNumbers => {\n          const pages: any[] = []\n          for (let i = 0; i < doc.numPages; i++) {\n            if (!pageNumbers || pageNumbers.indexOf(i + 1) !== -1) {\n              pages.push(from(doc.getPage(i + 1)))\n            }\n          }\n          return pages\n        })\n      ))\n    )\n  }\n\n}\n"]}