@depup/nestjs__common 11.1.16-depup.1

package/pipes/parse-array.pipe.js

@@ -0,0 +1,148 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ParseArrayPipe = void 0;
+const tslib_1 = require("tslib");
+const injectable_decorator_1 = require("../decorators/core/injectable.decorator");
+const optional_decorator_1 = require("../decorators/core/optional.decorator");
+const http_status_enum_1 = require("../enums/http-status.enum");
+const http_error_by_code_util_1 = require("../utils/http-error-by-code.util");
+const shared_utils_1 = require("../utils/shared.utils");
+const validation_pipe_1 = require("./validation.pipe");
+const VALIDATION_ERROR_MESSAGE = 'Validation failed (parsable array expected)';
+const DEFAULT_ARRAY_SEPARATOR = ',';
+/**
+ * Defines the built-in ParseArray Pipe
+ *
+ * @see [Built-in Pipes](https://docs.nestjs.com/pipes#built-in-pipes)
+ *
+ * @publicApi
+ */
+let ParseArrayPipe = class ParseArrayPipe {
+    constructor(options = {}) {
+        this.options = options;
+        this.validationPipe = new validation_pipe_1.ValidationPipe({
+            transform: true,
+            validateCustomDecorators: true,
+            ...options,
+        });
+        const { exceptionFactory, errorHttpStatusCode = http_status_enum_1.HttpStatus.BAD_REQUEST } = options;
+        this.exceptionFactory =
+            exceptionFactory ||
+                (error => new http_error_by_code_util_1.HttpErrorByCode[errorHttpStatusCode](error));
+    }
+    /**
+     * Method that accesses and performs optional transformation on argument for
+     * in-flight requests.
+     *
+     * @param value currently processed route argument
+     * @param metadata contains metadata about the currently processed route argument
+     */
+    async transform(value, metadata) {
+        if (!value && !this.options.optional) {
+            throw this.exceptionFactory(VALIDATION_ERROR_MESSAGE);
+        }
+        else if ((0, shared_utils_1.isNil)(value) && this.options.optional) {
+            return value;
+        }
+        if (!Array.isArray(value)) {
+            if (!(0, shared_utils_1.isString)(value)) {
+                throw this.exceptionFactory(VALIDATION_ERROR_MESSAGE);
+            }
+            else {
+                try {
+                    value = value
+                        .trim()
+                        .split(this.options.separator || DEFAULT_ARRAY_SEPARATOR);
+                }
+                catch {
+                    throw this.exceptionFactory(VALIDATION_ERROR_MESSAGE);
+                }
+            }
+        }
+        if (this.options.items) {
+            const validationMetadata = {
+                metatype: this.options.items,
+                type: 'query',
+            };
+            const isExpectedTypePrimitive = this.isExpectedTypePrimitive();
+            const toClassInstance = (item, index) => {
+                if (this.options.items !== String) {
+                    try {
+                        item = JSON.parse(item);
+                    }
+                    catch {
+                        // Do nothing
+                    }
+                }
+                if (isExpectedTypePrimitive) {
+                    return this.validatePrimitive(item, index);
+                }
+                return this.validationPipe.transform(item, validationMetadata);
+            };
+            if (this.options.stopAtFirstError === false) {
+                // strict compare to "false" to make sure
+                // that this option is disabled by default
+                let errors = [];
+                const targetArray = value;
+                for (let i = 0; i < targetArray.length; i++) {
+                    try {
+                        targetArray[i] = await toClassInstance(targetArray[i]);
+                    }
+                    catch (err) {
+                        let message;
+                        if (err.getResponse) {
+                            const response = err.getResponse();
+                            if (Array.isArray(response.message)) {
+                                message = response.message.map((item) => `[${i}] ${item}`);
+                            }
+                            else {
+                                message = `[${i}] ${response.message}`;
+                            }
+                        }
+                        else {
+                            message = err;
+                        }
+                        errors = errors.concat(message);
+                    }
+                }
+                if (errors.length > 0) {
+                    throw this.exceptionFactory(errors);
+                }
+                return targetArray;
+            }
+            else {
+                value = await Promise.all(value.map(toClassInstance));
+            }
+        }
+        return value;
+    }
+    isExpectedTypePrimitive() {
+        return [Boolean, Number, String].includes(this.options.items);
+    }
+    validatePrimitive(originalValue, index) {
+        if (this.options.items === Number) {
+            const value = originalValue !== null && originalValue !== '' ? +originalValue : NaN;
+            if (isNaN(value)) {
+                throw this.exceptionFactory(`${(0, shared_utils_1.isUndefined)(index) ? '' : `[${index}] `}item must be a number`);
+            }
+            return value;
+        }
+        else if (this.options.items === String) {
+            if (!(0, shared_utils_1.isString)(originalValue)) {
+                return `${originalValue}`;
+            }
+        }
+        else if (this.options.items === Boolean) {
+            if (typeof originalValue !== 'boolean') {
+                throw this.exceptionFactory(`${(0, shared_utils_1.isUndefined)(index) ? '' : `[${index}] `}item must be a boolean value`);
+            }
+        }
+        return originalValue;
+    }
+};
+exports.ParseArrayPipe = ParseArrayPipe;
+exports.ParseArrayPipe = ParseArrayPipe = tslib_1.__decorate([
+    (0, injectable_decorator_1.Injectable)(),
+    tslib_1.__param(0, (0, optional_decorator_1.Optional)()),
+    tslib_1.__metadata("design:paramtypes", [Object])
+], ParseArrayPipe);

package/pipes/parse-bool.pipe.d.ts

@@ -0,0 +1,55 @@
+import { ArgumentMetadata, PipeTransform } from '../interfaces/features/pipe-transform.interface';
+import { ErrorHttpStatusCode } from '../utils/http-error-by-code.util';
+/**
+ * @publicApi
+ */
+export interface ParseBoolPipeOptions {
+    /**
+     * The HTTP status code to be used in the response when the validation fails.
+     */
+    errorHttpStatusCode?: ErrorHttpStatusCode;
+    /**
+     * A factory function that returns an exception object to be thrown
+     * if validation fails.
+     * @param error Error message
+     * @returns The exception object
+     */
+    exceptionFactory?: (error: string) => any;
+    /**
+     * If true, the pipe will return null or undefined if the value is not provided
+     * @default false
+     */
+    optional?: boolean;
+}
+/**
+ * Defines the built-in ParseBool Pipe
+ *
+ * @see [Built-in Pipes](https://docs.nestjs.com/pipes#built-in-pipes)
+ *
+ * @publicApi
+ */
+export declare class ParseBoolPipe implements PipeTransform<string | boolean, Promise<boolean>> {
+    protected readonly options?: ParseBoolPipeOptions | undefined;
+    protected exceptionFactory: (error: string) => any;
+    constructor(options?: ParseBoolPipeOptions | undefined);
+    /**
+     * Method that accesses and performs optional transformation on argument for
+     * in-flight requests.
+     *
+     * @param value currently processed route argument
+     * @param metadata contains metadata about the currently processed route argument
+     */
+    transform(value: string | boolean, metadata: ArgumentMetadata): Promise<boolean>;
+    /**
+     * @param value currently processed route argument
+     * @returns `true` if `value` is said 'true', ie., if it is equal to the boolean
+     * `true` or the string `"true"`
+     */
+    protected isTrue(value: string | boolean): boolean;
+    /**
+     * @param value currently processed route argument
+     * @returns `true` if `value` is said 'false', ie., if it is equal to the boolean
+     * `false` or the string `"false"`
+     */
+    protected isFalse(value: string | boolean): boolean;
+}

package/pipes/parse-bool.pipe.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ParseBoolPipe = void 0;
+const tslib_1 = require("tslib");
+const injectable_decorator_1 = require("../decorators/core/injectable.decorator");
+const optional_decorator_1 = require("../decorators/core/optional.decorator");
+const http_status_enum_1 = require("../enums/http-status.enum");
+const http_error_by_code_util_1 = require("../utils/http-error-by-code.util");
+const shared_utils_1 = require("../utils/shared.utils");
+/**
+ * Defines the built-in ParseBool Pipe
+ *
+ * @see [Built-in Pipes](https://docs.nestjs.com/pipes#built-in-pipes)
+ *
+ * @publicApi
+ */
+let ParseBoolPipe = class ParseBoolPipe {
+    constructor(options) {
+        this.options = options;
+        options = options || {};
+        const { exceptionFactory, errorHttpStatusCode = http_status_enum_1.HttpStatus.BAD_REQUEST } = options;
+        this.exceptionFactory =
+            exceptionFactory ||
+                (error => new http_error_by_code_util_1.HttpErrorByCode[errorHttpStatusCode](error));
+    }
+    /**
+     * Method that accesses and performs optional transformation on argument for
+     * in-flight requests.
+     *
+     * @param value currently processed route argument
+     * @param metadata contains metadata about the currently processed route argument
+     */
+    async transform(value, metadata) {
+        if ((0, shared_utils_1.isNil)(value) && this.options?.optional) {
+            return value;
+        }
+        if (this.isTrue(value)) {
+            return true;
+        }
+        if (this.isFalse(value)) {
+            return false;
+        }
+        throw this.exceptionFactory('Validation failed (boolean string is expected)');
+    }
+    /**
+     * @param value currently processed route argument
+     * @returns `true` if `value` is said 'true', ie., if it is equal to the boolean
+     * `true` or the string `"true"`
+     */
+    isTrue(value) {
+        return value === true || value === 'true';
+    }
+    /**
+     * @param value currently processed route argument
+     * @returns `true` if `value` is said 'false', ie., if it is equal to the boolean
+     * `false` or the string `"false"`
+     */
+    isFalse(value) {
+        return value === false || value === 'false';
+    }
+};
+exports.ParseBoolPipe = ParseBoolPipe;
+exports.ParseBoolPipe = ParseBoolPipe = tslib_1.__decorate([
+    (0, injectable_decorator_1.Injectable)(),
+    tslib_1.__param(0, (0, optional_decorator_1.Optional)()),
+    tslib_1.__metadata("design:paramtypes", [Object])
+], ParseBoolPipe);

package/pipes/parse-date.pipe.d.ts

@@ -0,0 +1,37 @@
+import { PipeTransform } from '../interfaces/features/pipe-transform.interface';
+import { ErrorHttpStatusCode } from '../utils/http-error-by-code.util';
+export interface ParseDatePipeOptions {
+    /**
+     * If true, the pipe will return null or undefined if the value is not provided
+     * @default false
+     */
+    optional?: boolean;
+    /**
+     * Default value for the date
+     */
+    default?: () => Date;
+    /**
+     * The HTTP status code to be used in the response when the validation fails.
+     */
+    errorHttpStatusCode?: ErrorHttpStatusCode;
+    /**
+     * A factory function that returns an exception object to be thrown
+     * if validation fails.
+     * @param error Error message
+     * @returns The exception object
+     */
+    exceptionFactory?: (error: string) => any;
+}
+export declare class ParseDatePipe implements PipeTransform<string | number | undefined | null> {
+    private readonly options;
+    protected exceptionFactory: (error: string) => any;
+    constructor(options?: ParseDatePipeOptions);
+    /**
+     * Method that accesses and performs optional transformation on argument for
+     * in-flight requests.
+     *
+     * @param value currently processed route argument
+     * @param metadata contains metadata about the currently processed route argument
+     */
+    transform(value: string | number | undefined | null): Date | null | undefined;
+}

package/pipes/parse-date.pipe.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ParseDatePipe = void 0;
+const tslib_1 = require("tslib");
+const injectable_decorator_1 = require("../decorators/core/injectable.decorator");
+const http_status_enum_1 = require("../enums/http-status.enum");
+const http_error_by_code_util_1 = require("../utils/http-error-by-code.util");
+const shared_utils_1 = require("../utils/shared.utils");
+let ParseDatePipe = class ParseDatePipe {
+    constructor(options = {}) {
+        this.options = options;
+        const { exceptionFactory, errorHttpStatusCode = http_status_enum_1.HttpStatus.BAD_REQUEST } = options;
+        this.exceptionFactory =
+            exceptionFactory ||
+                (error => new http_error_by_code_util_1.HttpErrorByCode[errorHttpStatusCode](error));
+    }
+    /**
+     * Method that accesses and performs optional transformation on argument for
+     * in-flight requests.
+     *
+     * @param value currently processed route argument
+     * @param metadata contains metadata about the currently processed route argument
+     */
+    transform(value) {
+        if (this.options.optional && (0, shared_utils_1.isNil)(value)) {
+            return this.options.default ? this.options.default() : value;
+        }
+        if (!value) {
+            throw this.exceptionFactory('Validation failed (no Date provided)');
+        }
+        const transformedValue = new Date(value);
+        if (isNaN(transformedValue.getTime())) {
+            throw this.exceptionFactory('Validation failed (invalid date format)');
+        }
+        return transformedValue;
+    }
+};
+exports.ParseDatePipe = ParseDatePipe;
+exports.ParseDatePipe = ParseDatePipe = tslib_1.__decorate([
+    (0, injectable_decorator_1.Injectable)(),
+    tslib_1.__metadata("design:paramtypes", [Object])
+], ParseDatePipe);

package/pipes/parse-enum.pipe.d.ts

@@ -0,0 +1,46 @@
+import { ArgumentMetadata } from '../index';
+import { PipeTransform } from '../interfaces/features/pipe-transform.interface';
+import { ErrorHttpStatusCode } from '../utils/http-error-by-code.util';
+/**
+ * @publicApi
+ */
+export interface ParseEnumPipeOptions {
+    /**
+     * If true, the pipe will return null or undefined if the value is not provided
+     * @default false
+     */
+    optional?: boolean;
+    /**
+     * The HTTP status code to be used in the response when the validation fails.
+     */
+    errorHttpStatusCode?: ErrorHttpStatusCode;
+    /**
+     * A factory function that returns an exception object to be thrown
+     * if validation fails.
+     * @param error Error message
+     * @returns The exception object
+     */
+    exceptionFactory?: (error: string) => any;
+}
+/**
+ * Defines the built-in ParseEnum Pipe
+ *
+ * @see [Built-in Pipes](https://docs.nestjs.com/pipes#built-in-pipes)
+ *
+ * @publicApi
+ */
+export declare class ParseEnumPipe<T = any> implements PipeTransform<T> {
+    protected readonly enumType: T;
+    protected readonly options?: ParseEnumPipeOptions | undefined;
+    protected exceptionFactory: (error: string) => any;
+    constructor(enumType: T, options?: ParseEnumPipeOptions | undefined);
+    /**
+     * Method that accesses and performs optional transformation on argument for
+     * in-flight requests.
+     *
+     * @param value currently processed route argument
+     * @param metadata contains metadata about the currently processed route argument
+     */
+    transform(value: T, metadata: ArgumentMetadata): Promise<T>;
+    protected isEnum(value: T): boolean;
+}

package/pipes/parse-enum.pipe.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ParseEnumPipe = void 0;
+const tslib_1 = require("tslib");
+const core_1 = require("../decorators/core");
+const index_1 = require("../index");
+const http_error_by_code_util_1 = require("../utils/http-error-by-code.util");
+const shared_utils_1 = require("../utils/shared.utils");
+/**
+ * Defines the built-in ParseEnum Pipe
+ *
+ * @see [Built-in Pipes](https://docs.nestjs.com/pipes#built-in-pipes)
+ *
+ * @publicApi
+ */
+let ParseEnumPipe = class ParseEnumPipe {
+    constructor(enumType, options) {
+        this.enumType = enumType;
+        this.options = options;
+        if (!enumType) {
+            throw new Error(`"ParseEnumPipe" requires "enumType" argument specified (to validate input values).`);
+        }
+        options = options || {};
+        const { exceptionFactory, errorHttpStatusCode = index_1.HttpStatus.BAD_REQUEST } = options;
+        this.exceptionFactory =
+            exceptionFactory ||
+                (error => new http_error_by_code_util_1.HttpErrorByCode[errorHttpStatusCode](error));
+    }
+    /**
+     * Method that accesses and performs optional transformation on argument for
+     * in-flight requests.
+     *
+     * @param value currently processed route argument
+     * @param metadata contains metadata about the currently processed route argument
+     */
+    async transform(value, metadata) {
+        if ((0, shared_utils_1.isNil)(value) && this.options?.optional) {
+            return value;
+        }
+        if (!this.isEnum(value)) {
+            throw this.exceptionFactory('Validation failed (enum string is expected)');
+        }
+        return value;
+    }
+    isEnum(value) {
+        const enumValues = Object.keys(this.enumType).map(item => this.enumType[item]);
+        return enumValues.includes(value);
+    }
+};
+exports.ParseEnumPipe = ParseEnumPipe;
+exports.ParseEnumPipe = ParseEnumPipe = tslib_1.__decorate([
+    (0, core_1.Injectable)(),
+    tslib_1.__param(1, (0, core_1.Optional)()),
+    tslib_1.__metadata("design:paramtypes", [Object, Object])
+], ParseEnumPipe);

package/pipes/parse-float.pipe.d.ts

@@ -0,0 +1,49 @@
+import { ArgumentMetadata } from '../index';
+import { PipeTransform } from '../interfaces/features/pipe-transform.interface';
+import { ErrorHttpStatusCode } from '../utils/http-error-by-code.util';
+/**
+ * @publicApi
+ */
+export interface ParseFloatPipeOptions {
+    /**
+     * The HTTP status code to be used in the response when the validation fails.
+     */
+    errorHttpStatusCode?: ErrorHttpStatusCode;
+    /**
+     * A factory function that returns an exception object to be thrown
+     * if validation fails.
+     * @param error Error message
+     * @returns The exception object
+     */
+    exceptionFactory?: (error: string) => any;
+    /**
+     * If true, the pipe will return null or undefined if the value is not provided
+     * @default false
+     */
+    optional?: boolean;
+}
+/**
+ * Defines the built-in ParseFloat Pipe
+ *
+ * @see [Built-in Pipes](https://docs.nestjs.com/pipes#built-in-pipes)
+ *
+ * @publicApi
+ */
+export declare class ParseFloatPipe implements PipeTransform<string> {
+    protected readonly options?: ParseFloatPipeOptions | undefined;
+    protected exceptionFactory: (error: string) => any;
+    constructor(options?: ParseFloatPipeOptions | undefined);
+    /**
+     * Method that accesses and performs optional transformation on argument for
+     * in-flight requests.
+     *
+     * @param value currently processed route argument
+     * @param metadata contains metadata about the currently processed route argument
+     */
+    transform(value: string, metadata: ArgumentMetadata): Promise<number>;
+    /**
+     * @param value currently processed route argument
+     * @returns `true` if `value` is a valid float number
+     */
+    protected isNumeric(value: string): boolean;
+}

package/pipes/parse-float.pipe.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ParseFloatPipe = void 0;
+const tslib_1 = require("tslib");
+const core_1 = require("../decorators/core");
+const index_1 = require("../index");
+const http_error_by_code_util_1 = require("../utils/http-error-by-code.util");
+const shared_utils_1 = require("../utils/shared.utils");
+/**
+ * Defines the built-in ParseFloat Pipe
+ *
+ * @see [Built-in Pipes](https://docs.nestjs.com/pipes#built-in-pipes)
+ *
+ * @publicApi
+ */
+let ParseFloatPipe = class ParseFloatPipe {
+    constructor(options) {
+        this.options = options;
+        options = options || {};
+        const { exceptionFactory, errorHttpStatusCode = index_1.HttpStatus.BAD_REQUEST } = options;
+        this.exceptionFactory =
+            exceptionFactory ||
+                (error => new http_error_by_code_util_1.HttpErrorByCode[errorHttpStatusCode](error));
+    }
+    /**
+     * Method that accesses and performs optional transformation on argument for
+     * in-flight requests.
+     *
+     * @param value currently processed route argument
+     * @param metadata contains metadata about the currently processed route argument
+     */
+    async transform(value, metadata) {
+        if ((0, shared_utils_1.isNil)(value) && this.options?.optional) {
+            return value;
+        }
+        if (!this.isNumeric(value)) {
+            throw this.exceptionFactory('Validation failed (numeric string is expected)');
+        }
+        return parseFloat(value);
+    }
+    /**
+     * @param value currently processed route argument
+     * @returns `true` if `value` is a valid float number
+     */
+    isNumeric(value) {
+        return (['string', 'number'].includes(typeof value) &&
+            !isNaN(parseFloat(value)) &&
+            isFinite(value));
+    }
+};
+exports.ParseFloatPipe = ParseFloatPipe;
+exports.ParseFloatPipe = ParseFloatPipe = tslib_1.__decorate([
+    (0, core_1.Injectable)(),
+    tslib_1.__param(0, (0, core_1.Optional)()),
+    tslib_1.__metadata("design:paramtypes", [Object])
+], ParseFloatPipe);

package/pipes/parse-int.pipe.d.ts

@@ -0,0 +1,48 @@
+import { ArgumentMetadata, PipeTransform } from '../interfaces/features/pipe-transform.interface';
+import { ErrorHttpStatusCode } from '../utils/http-error-by-code.util';
+/**
+ * @publicApi
+ */
+export interface ParseIntPipeOptions {
+    /**
+     * The HTTP status code to be used in the response when the validation fails.
+     */
+    errorHttpStatusCode?: ErrorHttpStatusCode;
+    /**
+     * A factory function that returns an exception object to be thrown
+     * if validation fails.
+     * @param error Error message
+     * @returns The exception object
+     */
+    exceptionFactory?: (error: string) => any;
+    /**
+     * If true, the pipe will return null or undefined if the value is not provided
+     * @default false
+     */
+    optional?: boolean;
+}
+/**
+ * Defines the built-in ParseInt Pipe
+ *
+ * @see [Built-in Pipes](https://docs.nestjs.com/pipes#built-in-pipes)
+ *
+ * @publicApi
+ */
+export declare class ParseIntPipe implements PipeTransform<string> {
+    protected readonly options?: ParseIntPipeOptions | undefined;
+    protected exceptionFactory: (error: string) => any;
+    constructor(options?: ParseIntPipeOptions | undefined);
+    /**
+     * Method that accesses and performs optional transformation on argument for
+     * in-flight requests.
+     *
+     * @param value currently processed route argument
+     * @param metadata contains metadata about the currently processed route argument
+     */
+    transform(value: string, metadata: ArgumentMetadata): Promise<number>;
+    /**
+     * @param value currently processed route argument
+     * @returns `true` if `value` is a valid integer number
+     */
+    protected isNumeric(value: string): boolean;
+}

package/pipes/parse-int.pipe.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ParseIntPipe = void 0;
+const tslib_1 = require("tslib");
+const injectable_decorator_1 = require("../decorators/core/injectable.decorator");
+const optional_decorator_1 = require("../decorators/core/optional.decorator");
+const http_status_enum_1 = require("../enums/http-status.enum");
+const http_error_by_code_util_1 = require("../utils/http-error-by-code.util");
+const shared_utils_1 = require("../utils/shared.utils");
+/**
+ * Defines the built-in ParseInt Pipe
+ *
+ * @see [Built-in Pipes](https://docs.nestjs.com/pipes#built-in-pipes)
+ *
+ * @publicApi
+ */
+let ParseIntPipe = class ParseIntPipe {
+    constructor(options) {
+        this.options = options;
+        options = options || {};
+        const { exceptionFactory, errorHttpStatusCode = http_status_enum_1.HttpStatus.BAD_REQUEST } = options;
+        this.exceptionFactory =
+            exceptionFactory ||
+                (error => new http_error_by_code_util_1.HttpErrorByCode[errorHttpStatusCode](error));
+    }
+    /**
+     * Method that accesses and performs optional transformation on argument for
+     * in-flight requests.
+     *
+     * @param value currently processed route argument
+     * @param metadata contains metadata about the currently processed route argument
+     */
+    async transform(value, metadata) {
+        if ((0, shared_utils_1.isNil)(value) && this.options?.optional) {
+            return value;
+        }
+        if (!this.isNumeric(value)) {
+            throw this.exceptionFactory('Validation failed (numeric string is expected)');
+        }
+        return parseInt(value, 10);
+    }
+    /**
+     * @param value currently processed route argument
+     * @returns `true` if `value` is a valid integer number
+     */
+    isNumeric(value) {
+        return (['string', 'number'].includes(typeof value) &&
+            /^-?\d+$/.test(value) &&
+            isFinite(value));
+    }
+};
+exports.ParseIntPipe = ParseIntPipe;
+exports.ParseIntPipe = ParseIntPipe = tslib_1.__decorate([
+    (0, injectable_decorator_1.Injectable)(),
+    tslib_1.__param(0, (0, optional_decorator_1.Optional)()),
+    tslib_1.__metadata("design:paramtypes", [Object])
+], ParseIntPipe);