@mediusinc/mng-commons 5.0.0-rc.0-c31d5206 → 5.0.0-rc.1

package/esm2022/core/error/error-helpers.mjs

@@ -0,0 +1,247 @@
+import { HttpErrorResponse } from '@angular/common/http';
+import { stringify } from '../helpers/string';
+import { LogLevelEnum } from '../log/log.model';
+import { ACommonsErrorBase, CommonsHttpError, CommonsInternalError } from './error.model';
+/**
+ * Converts RxJS subscription error to CommonsError.
+ * @param error Error.
+ * @param name Optional name to write in commons error.
+ * @param details Optional details of error.
+ */
+export function fromSubscribeError(error, name, details) {
+    const opts = {
+        name,
+        details,
+        location: window?.location?.href
+    };
+    if (error instanceof HttpErrorResponse) {
+        return new CommonsHttpError(error.message ?? 'Http Error occurred', error, opts);
+    }
+    else {
+        opts.cause = error;
+        return new CommonsInternalError(error.message ?? 'Internal Error occurred', opts);
+    }
+}
+/**
+ * Checks if error is Http error (Angular or Commons).
+ * @param error
+ */
+export function isHttpErrorResponse(error) {
+    return error instanceof HttpErrorResponse || error instanceof CommonsHttpError || error?.httpError instanceof HttpErrorResponse;
+}
+/**
+ * Gets HttpErrorResponse from error (Angular or Commons).
+ * @param error Error.
+ */
+export function getHttpErrorResponse(error) {
+    if (error instanceof HttpErrorResponse) {
+        return error;
+    }
+    else if (error instanceof CommonsHttpError) {
+        return error.httpError;
+    }
+    else if (error?.httpError instanceof HttpErrorResponse) {
+        return error.httpError;
+    }
+    else {
+        return null;
+    }
+}
+/**
+ * Gets HttpErrorResponse status from error (Angular or Commons).
+ * @param error Error.
+ */
+export function getHttpErrorResponseStatus(error) {
+    return getHttpErrorResponse(error)?.status ?? null;
+}
+/**
+ * Get error log level. All is error, except if error is http error with status >=400 and <500.
+ * @param error Error.
+ */
+export function getErrorLogLevel(error) {
+    if (isHttpErrorResponse(error)) {
+        const status = getHttpErrorResponseStatus(error);
+        if (status && status >= 400 && status < 500) {
+            return LogLevelEnum.Warning;
+        }
+    }
+    return LogLevelEnum.Error;
+}
+/**
+ * Get error name (prototype name or type from commons error if name is not provided).
+ * @param error Error.
+ */
+export function getErrorName(error) {
+    if (error instanceof ACommonsErrorBase) {
+        return error.name ?? error.type;
+    }
+    else {
+        return error.name;
+    }
+}
+/**
+ * Writes http error to string with all headers and body.
+ * @param error Http response error.
+ * @param opts Options for hiding parts of error:
+ *  - hideMessage Hides message of error (message include url, status and status text!).
+ *  - hideHeaders Hides headers.
+ *  - hideBody Hides JSON representation of body.
+ */
+export function httpErrorResponseToString(error, opts) {
+    let str = opts?.hideMessage ? '' : `${error.message}\n`; // message should already include url, status, etc.
+    if (!opts?.hideHeaders) {
+        str += `Http Response Headers: ${error.headers.keys().reduce((acc, key) => `${acc}[${key}: ${error.headers.get(key)}]`, '')}`;
+    }
+    if (!opts?.hideBody) {
+        str += `\nHttp Response Body: ${stringify(error.error)}`;
+    }
+    return str;
+}
+/**
+ * Error to string.
+ * @param error Error.
+ * @param opts Options for hiding parts of error:
+ * - hideMessage Hides message of error.
+ * - hideName Hides error name.
+ * - hideCause Hides cause of an error (if present, see @link(errorCauseToString) for other options).
+ * - hideStack Hides stack of an error (if present).
+ * - hideDetails Hides JSON detail's representation of error (if present).
+ * - hideLocation Hides location (URL) where error was thrown.
+ * - hideHttp Hides http error portion of error if http error response (see @link(httpErrorResponseToString) for other options).
+ */
+export function errorToString(error, opts) {
+    if (error instanceof ACommonsErrorBase) {
+        return commonsErrorToString(error, opts);
+    }
+    else if (error instanceof HttpErrorResponse) {
+        return httpErrorResponseToString(error, opts);
+    }
+    const strBlocks = [];
+    if (!opts?.hideMessage) {
+        strBlocks.push(error.message);
+    }
+    if (error.name) {
+        strBlocks.push(`Error name: ${error.name}`);
+    }
+    if (!opts?.hideCause) {
+        strBlocks.push(errorCauseToString(error, opts));
+    }
+    if (!opts?.hideStack && error.stack) {
+        strBlocks.push(`Stack trace:\n${error.stack}`);
+    }
+    return strBlocks.filter(s => s.trim().length > 0).join('\n');
+}
+/**
+ * Commons error to string.
+ * @param error Commons error.
+ * @param opts Options for hiding parts of error:
+ * - hideMessage Hides message of error.
+ * - hideName Hides error name.
+ * - hideCause Hides cause of an error (if present, see @link(errorCauseToString) for other options).
+ * - hideStack Hides stack of an error (if present).
+ * - hideDetails Hides JSON detail's representation of error (if present).
+ * - hideLocation Hides location (URL) where error was thrown.
+ * - hideHttp Hides http error portion of error if http error response (see @link(httpErrorResponseToString) for other options).
+ * - hideItems Hides all item information (http body, action context data).
+ * - hideActionData See @link(commonsActionErrorContextToString) for additional info.
+ * - hideQueryParams See @link(commonsActionErrorContextToString) for additional info.
+ */
+export function commonsErrorToString(error, opts) {
+    const strBlocks = [];
+    if (!opts?.hideMessage) {
+        strBlocks.push(`${error.message}${error.messageCode ? ` (code: ${error.messageCode})` : ''}`);
+    }
+    if (!opts?.hideName) {
+        strBlocks.push(`Error name: ${error.name ?? error.type} ${error.name ? `(${error.type})` : ''}`);
+    }
+    if (!opts?.hideLocation && error.location) {
+        strBlocks.push(`Location: ${error.location}`);
+    }
+    let isHttp = false;
+    if (!opts?.hideHttp && error instanceof CommonsHttpError) {
+        strBlocks.push(httpErrorResponseToString(error.httpError, {
+            hideBody: opts?.hideItems || opts?.hideBody,
+            hideHeaders: opts?.hideHeaders,
+            hideMessage: error.message.indexOf(error.httpError.message) >= 0
+        }));
+        isHttp = true;
+    }
+    if (error.type === 'CommonsActionError') {
+        const actionError = error;
+        if (actionError.actionContext) {
+            strBlocks.push(commonsActionErrorContextToString(actionError, opts));
+        }
+        if (!opts?.hideHttp && actionError.httpError instanceof HttpErrorResponse) {
+            strBlocks.push(httpErrorResponseToString(actionError.httpError, {
+                hideBody: opts?.hideItems || opts?.hideBody,
+                hideHeaders: opts?.hideHeaders,
+                hideMessage: error.message.indexOf(actionError.httpError.message) >= 0
+            }));
+            isHttp = true;
+        }
+    }
+    if (!opts?.hideDetails && error.details) {
+        strBlocks.push(`Details: ${stringify(error.details)}`);
+    }
+    if (!opts?.hideCause && (!isHttp || !(error.cause instanceof HttpErrorResponse))) {
+        strBlocks.push(errorCauseToString(error, opts));
+    }
+    if (!opts?.hideStack && error.stack) {
+        strBlocks.push(`Stack trace:\n${error.stack}`);
+    }
+    return strBlocks.filter(s => s.trim().length > 0).join('\n');
+}
+/**
+ * Writes commons action error info from context as string.
+ * @param error Commons action error.
+ * @param opts Options for hiding parts of error:
+ * - hideItems Hides all item related information (item, form item, submit item, ...).
+ * - hideActionData Hides action data.
+ * - hideQueryParams Hides query params.
+ */
+export function commonsActionErrorContextToString(error, opts) {
+    let paramsMessage = '';
+    if (error.actionContext?.parameters) {
+        if (error.actionContext?.parameters.itemId) {
+            paramsMessage += `[itemId: ${error.actionContext.parameters.itemId}]`;
+        }
+        if (!opts?.hideItems && error.actionContext?.parameters.item) {
+            paramsMessage += `[item: ${stringify(error.actionContext.parameters.item)}]`;
+        }
+        if (!opts?.hideActionData && error.actionContext?.parameters.actionData) {
+            paramsMessage += Object.entries(error.actionContext?.parameters.actionData).reduce((acc, [key, value]) => `${acc}[actionData ${key}: ${stringify(value)}]`, '');
+        }
+        if (!opts?.hideQueryParams && error.actionContext?.parameters.dataListParams) {
+            paramsMessage += `[dataListParams: ${stringify(error.actionContext.parameters.dataListParams)}]`;
+        }
+        if (!opts?.hideItems && error.actionContext?.parameters.formItem) {
+            paramsMessage += `[formItem: ${stringify(error.actionContext.parameters.formItem)}]`;
+        }
+        if (!opts?.hideItems && error.actionContext?.parameters.submitResult) {
+            paramsMessage += `[formItem: ${stringify(error.actionContext.parameters.submitResult)}]`;
+        }
+        if (error.actionContext?.parameters.locale) {
+            paramsMessage += `[locale: ${stringify(error.actionContext.parameters.locale)}]`;
+        }
+    }
+    return paramsMessage;
+}
+/**
+ * Writes cause of an error as string.
+ * @param error Error.
+ * @param opts Options for hiding parts of error:
+ * - causeOnErrorOnly Prints only if cause is instance of error.
+ * - causeAsJson Print error cause as a JSON (by default, if error only message and name will be printed).
+ */
+export function errorCauseToString(error, opts) {
+    // if already logged as http error, check that cause is not also http error (cause it is usually duplicated)
+    if (error.cause && (!opts?.causeOnErrorOnly || error.cause instanceof Error)) {
+        const needsStringify = opts?.causeAsJson || !(error.cause instanceof Error);
+        if (!opts?.causeOnErrorOnly || error.cause instanceof Error) {
+            return ('Caused by: ' +
+                (needsStringify ? stringify(error.cause) : `${error.cause.message}${error.cause.name ? ` (${error.cause.name})` : ''}`));
+        }
+    }
+    return '';
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"error-helpers.js","sourceRoot":"","sources":["../../../../core/src/error/error-helpers.ts"],"names":[],"mappings":"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","sourcesContent":["import {HttpErrorResponse} from '@angular/common/http';\n\nimport {stringify} from '../helpers/string';\nimport {LogLevelEnum} from '../log/log.model';\nimport {ACommonsErrorBase, CommonsErrorBaseOptions, CommonsHttpError, CommonsInternalError, ICommonsActionError} from './error.model';\n\n/**\n * Converts RxJS subscription error to CommonsError.\n * @param error Error.\n * @param name Optional name to write in commons error.\n * @param details Optional details of error.\n */\nexport function fromSubscribeError(error: any, name?: string, details?: any): ACommonsErrorBase {\n    const opts: CommonsErrorBaseOptions = {\n        name,\n        details,\n        location: window?.location?.href\n    };\n\n    if (error instanceof HttpErrorResponse) {\n        return new CommonsHttpError(error.message ?? 'Http Error occurred', error, opts);\n    } else {\n        opts.cause = error;\n        return new CommonsInternalError(error.message ?? 'Internal Error occurred', opts);\n    }\n}\n\n/**\n * Checks if error is Http error (Angular or Commons).\n * @param error\n */\nexport function isHttpErrorResponse(error: any) {\n    return error instanceof HttpErrorResponse || error instanceof CommonsHttpError || (error as ICommonsActionError | undefined)?.httpError instanceof HttpErrorResponse;\n}\n\n/**\n * Gets HttpErrorResponse from error (Angular or Commons).\n * @param error Error.\n */\nexport function getHttpErrorResponse(error: any): HttpErrorResponse | null {\n    if (error instanceof HttpErrorResponse) {\n        return error;\n    } else if (error instanceof CommonsHttpError) {\n        return error.httpError;\n    } else if ((error as ICommonsActionError | undefined)?.httpError instanceof HttpErrorResponse) {\n        return error.httpError;\n    } else {\n        return null;\n    }\n}\n\n/**\n * Gets HttpErrorResponse status from error (Angular or Commons).\n * @param error Error.\n */\nexport function getHttpErrorResponseStatus(error: any): number | null {\n    return getHttpErrorResponse(error)?.status ?? null;\n}\n\n/**\n * Get error log level. All is error, except if error is http error with status >=400 and <500.\n * @param error Error.\n */\nexport function getErrorLogLevel(error: any): LogLevelEnum {\n    if (isHttpErrorResponse(error)) {\n        const status = getHttpErrorResponseStatus(error);\n        if (status && status >= 400 && status < 500) {\n            return LogLevelEnum.Warning;\n        }\n    }\n    return LogLevelEnum.Error;\n}\n\n/**\n * Get error name (prototype name or type from commons error if name is not provided).\n * @param error Error.\n */\nexport function getErrorName(error: any): string {\n    if (error instanceof ACommonsErrorBase) {\n        return error.name ?? error.type;\n    } else {\n        return error.name;\n    }\n}\n\n/**\n * Writes http error to string with all headers and body.\n * @param error Http response error.\n * @param opts Options for hiding parts of error:\n *  - hideMessage Hides message of error (message include url, status and status text!).\n *  - hideHeaders Hides headers.\n *  - hideBody Hides JSON representation of body.\n */\nexport function httpErrorResponseToString(error: HttpErrorResponse, opts?: HttpErrorResponseToStringOptionsType): string {\n    let str = opts?.hideMessage ? '' : `${error.message}\\n`; // message should already include url, status, etc.\n    if (!opts?.hideHeaders) {\n        str += `Http Response Headers: ${error.headers.keys().reduce((acc, key) => `${acc}[${key}: ${error.headers.get(key)}]`, '')}`;\n    }\n    if (!opts?.hideBody) {\n        str += `\\nHttp Response Body: ${stringify(error.error)}`;\n    }\n    return str;\n}\n\n/**\n * Error to string.\n * @param error Error.\n * @param opts Options for hiding parts of error:\n * - hideMessage Hides message of error.\n * - hideName Hides error name.\n * - hideCause Hides cause of an error (if present, see @link(errorCauseToString) for other options).\n * - hideStack Hides stack of an error (if present).\n * - hideDetails Hides JSON detail's representation of error (if present).\n * - hideLocation Hides location (URL) where error was thrown.\n * - hideHttp Hides http error portion of error if http error response (see @link(httpErrorResponseToString) for other options).\n */\nexport function errorToString(error: Error, opts?: ErrorToStringOptionsType): string {\n    if (error instanceof ACommonsErrorBase) {\n        return commonsErrorToString(error, opts);\n    } else if (error instanceof HttpErrorResponse) {\n        return httpErrorResponseToString(error, opts);\n    }\n\n    const strBlocks: string[] = [];\n    if (!opts?.hideMessage) {\n        strBlocks.push(error.message);\n    }\n    if (error.name) {\n        strBlocks.push(`Error name: ${error.name}`);\n    }\n    if (!opts?.hideCause) {\n        strBlocks.push(errorCauseToString(error, opts));\n    }\n    if (!opts?.hideStack && error.stack) {\n        strBlocks.push(`Stack trace:\\n${error.stack}`);\n    }\n\n    return strBlocks.filter(s => s.trim().length > 0).join('\\n');\n}\n\n/**\n * Commons error to string.\n * @param error Commons error.\n * @param opts Options for hiding parts of error:\n * - hideMessage Hides message of error.\n * - hideName Hides error name.\n * - hideCause Hides cause of an error (if present, see @link(errorCauseToString) for other options).\n * - hideStack Hides stack of an error (if present).\n * - hideDetails Hides JSON detail's representation of error (if present).\n * - hideLocation Hides location (URL) where error was thrown.\n * - hideHttp Hides http error portion of error if http error response (see @link(httpErrorResponseToString) for other options).\n * - hideItems Hides all item information (http body, action context data).\n * - hideActionData See @link(commonsActionErrorContextToString) for additional info.\n * - hideQueryParams See @link(commonsActionErrorContextToString) for additional info.\n */\nexport function commonsErrorToString(error: ACommonsErrorBase, opts?: ErrorToStringOptionsType): string {\n    const strBlocks: string[] = [];\n    if (!opts?.hideMessage) {\n        strBlocks.push(`${error.message}${error.messageCode ? ` (code: ${error.messageCode})` : ''}`);\n    }\n    if (!opts?.hideName) {\n        strBlocks.push(`Error name: ${error.name ?? error.type} ${error.name ? `(${error.type})` : ''}`);\n    }\n    if (!opts?.hideLocation && error.location) {\n        strBlocks.push(`Location: ${error.location}`);\n    }\n\n    let isHttp = false;\n    if (!opts?.hideHttp && error instanceof CommonsHttpError) {\n        strBlocks.push(\n            httpErrorResponseToString(error.httpError, {\n                hideBody: opts?.hideItems || opts?.hideBody,\n                hideHeaders: opts?.hideHeaders,\n                hideMessage: error.message.indexOf(error.httpError.message) >= 0\n            })\n        );\n        isHttp = true;\n    }\n    if (error.type === 'CommonsActionError') {\n        const actionError = error as unknown as ICommonsActionError;\n        if (actionError.actionContext) {\n            strBlocks.push(commonsActionErrorContextToString(actionError, opts));\n        }\n        if (!opts?.hideHttp && actionError.httpError instanceof HttpErrorResponse) {\n            strBlocks.push(\n                httpErrorResponseToString(actionError.httpError, {\n                    hideBody: opts?.hideItems || opts?.hideBody,\n                    hideHeaders: opts?.hideHeaders,\n                    hideMessage: error.message.indexOf(actionError.httpError.message) >= 0\n                })\n            );\n            isHttp = true;\n        }\n    }\n\n    if (!opts?.hideDetails && error.details) {\n        strBlocks.push(`Details: ${stringify(error.details)}`);\n    }\n    if (!opts?.hideCause && (!isHttp || !(error.cause instanceof HttpErrorResponse))) {\n        strBlocks.push(errorCauseToString(error, opts));\n    }\n    if (!opts?.hideStack && error.stack) {\n        strBlocks.push(`Stack trace:\\n${error.stack}`);\n    }\n\n    return strBlocks.filter(s => s.trim().length > 0).join('\\n');\n}\n\n/**\n * Writes commons action error info from context as string.\n * @param error Commons action error.\n * @param opts Options for hiding parts of error:\n * - hideItems Hides all item related information (item, form item, submit item, ...).\n * - hideActionData Hides action data.\n * - hideQueryParams Hides query params.\n */\nexport function commonsActionErrorContextToString(error: ICommonsActionError, opts?: ActionErrorContextToStringOptionsType): string {\n    let paramsMessage = '';\n    if (error.actionContext?.parameters) {\n        if (error.actionContext?.parameters.itemId) {\n            paramsMessage += `[itemId: ${error.actionContext.parameters.itemId}]`;\n        }\n        if (!opts?.hideItems && error.actionContext?.parameters.item) {\n            paramsMessage += `[item: ${stringify(error.actionContext.parameters.item)}]`;\n        }\n        if (!opts?.hideActionData && error.actionContext?.parameters.actionData) {\n            paramsMessage += Object.entries(error.actionContext?.parameters.actionData).reduce((acc, [key, value]) => `${acc}[actionData ${key}: ${stringify(value)}]`, '');\n        }\n        if (!opts?.hideQueryParams && error.actionContext?.parameters.dataListParams) {\n            paramsMessage += `[dataListParams: ${stringify(error.actionContext.parameters.dataListParams)}]`;\n        }\n        if (!opts?.hideItems && error.actionContext?.parameters.formItem) {\n            paramsMessage += `[formItem: ${stringify(error.actionContext.parameters.formItem)}]`;\n        }\n        if (!opts?.hideItems && error.actionContext?.parameters.submitResult) {\n            paramsMessage += `[formItem: ${stringify(error.actionContext.parameters.submitResult)}]`;\n        }\n        if (error.actionContext?.parameters.locale) {\n            paramsMessage += `[locale: ${stringify(error.actionContext.parameters.locale)}]`;\n        }\n    }\n\n    return paramsMessage;\n}\n\n/**\n * Writes cause of an error as string.\n * @param error Error.\n * @param opts Options for hiding parts of error:\n * - causeOnErrorOnly Prints only if cause is instance of error.\n * - causeAsJson Print error cause as a JSON (by default, if error only message and name will be printed).\n */\nexport function errorCauseToString(error: Error, opts?: ErrorCauseToStringOptionsType): string {\n    // if already logged as http error, check that cause is not also http error (cause it is usually duplicated)\n    if (error.cause && (!opts?.causeOnErrorOnly || error.cause instanceof Error)) {\n        const needsStringify = opts?.causeAsJson || !(error.cause instanceof Error);\n        if (!opts?.causeOnErrorOnly || error.cause instanceof Error) {\n            return (\n                'Caused by: ' +\n                (needsStringify ? stringify(error.cause) : `${(error.cause as Error).message}${(error.cause as Error).name ? ` (${(error.cause as Error).name})` : ''}`)\n            );\n        }\n    }\n    return '';\n}\n\nexport type ErrorToStringOptionsType = ErrorToStringOptionsBaseType &\n    HttpErrorResponseToStringOptionsType &\n    ActionErrorContextToStringOptionsType &\n    ErrorCauseToStringOptionsType & {\n        hideDetails?: boolean;\n        hideLocation?: boolean;\n    };\n\nexport interface ErrorToStringOptionsBaseType {\n    hideName?: boolean;\n    hideStack?: boolean;\n    hideCause?: boolean;\n    hideHttp?: boolean;\n}\n\nexport interface HttpErrorResponseToStringOptionsType {\n    hideMessage?: boolean;\n    hideHeaders?: boolean;\n    hideBody?: boolean;\n}\n\nexport interface ActionErrorContextToStringOptionsType {\n    hideItems?: boolean;\n    hideActionData?: boolean;\n    hideQueryParams?: boolean;\n}\n\nexport interface ErrorCauseToStringOptionsType {\n    causeOnErrorOnly?: boolean;\n    causeAsJson?: boolean;\n}\n"]}

package/esm2022/core/error/error.model.mjs

@@ -0,0 +1,32 @@
+export class ACommonsErrorBase extends Error {
+    constructor(message, options) {
+        super(message);
+        this.name = options?.name ?? 'MngError';
+        this.messageCode = options?.messageCode;
+        this.location = options?.location ?? window?.location?.href;
+        this.cause = options?.cause;
+        this.stack = options?.stack ?? (options?.cause ? options.cause.stack : new Error(message).stack);
+        this.details = options?.details;
+    }
+}
+export class CommonsInternalError extends ACommonsErrorBase {
+    constructor(message, options) {
+        super(message, {
+            name: 'CommonsInternalError',
+            ...options
+        });
+        this.type = 'CommonsInternalError';
+    }
+}
+export class CommonsHttpError extends ACommonsErrorBase {
+    constructor(message, httpError, options) {
+        super(message, {
+            name: 'CommonsHttpError_' + httpError.url,
+            cause: httpError,
+            ...options
+        });
+        this.type = 'CommonsHttpError';
+        this.httpError = httpError;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/core/helpers/coercion.mjs

@@ -0,0 +1,52 @@
+import { booleanAttribute, numberAttribute } from '@angular/core';
+import { isObservable, of } from 'rxjs';
+import { CommonsInternalError } from '../error/error.model';
+export function boolean$Attribute(value) {
+    return isObservable(value) ? value : of(booleanAttribute(value));
+}
+export function number$Attribute(value) {
+    return isObservable(value) ? value : of(numberAttribute(value));
+}
+export const toObservable = (value) => {
+    return isObservable(value) ? value : of(value);
+};
+export const itemIdToNumber = (value) => {
+    if (typeof value === 'number') {
+        return value;
+    }
+    else if (typeof value === 'string') {
+        const num = +value;
+        if (!isNaN(num)) {
+            return num;
+        }
+        throw new CommonsInternalError(`ItemId is a string, but could not be transformed to number: ${value}`);
+    }
+    else {
+        throw new CommonsInternalError(`ItemId is not a number: ${value}`);
+    }
+};
+export const itemIdToString = (value) => {
+    if (typeof value === 'string') {
+        return value;
+    }
+    else {
+        throw new CommonsInternalError(`ItemId is not a string: ${value}`);
+    }
+};
+export const itemIdToDefined = (value) => {
+    if (typeof value === 'undefined') {
+        throw new CommonsInternalError(`ItemId is not defined: ${value}`);
+    }
+    else {
+        return value;
+    }
+};
+export const valueToDefined = (value) => {
+    if (typeof value === 'undefined' || value === null) {
+        throw new CommonsInternalError(`Value is null or not defined: ${value}`);
+    }
+    else {
+        return value;
+    }
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29lcmNpb24uanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9jb3JlL3NyYy9oZWxwZXJzL2NvZXJjaW9uLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBQyxnQkFBZ0IsRUFBRSxlQUFlLEVBQUMsTUFBTSxlQUFlLENBQUM7QUFFaEUsT0FBTyxFQUFhLFlBQVksRUFBRSxFQUFFLEVBQUMsTUFBTSxNQUFNLENBQUM7QUFFbEQsT0FBTyxFQUFDLG9CQUFvQixFQUFDLE1BQU0sc0JBQXNCLENBQUM7QUFHMUQsTUFBTSxVQUFVLGlCQUFpQixDQUFDLEtBQWM7SUFDNUMsT0FBTyxZQUFZLENBQUMsS0FBSyxDQUFDLENBQUMsQ0FBQyxDQUFFLEtBQTZCLENBQUMsQ0FBQyxDQUFDLEVBQUUsQ0FBQyxnQkFBZ0IsQ0FBQyxLQUFLLENBQUMsQ0FBQyxDQUFDO0FBQzlGLENBQUM7QUFFRCxNQUFNLFVBQVUsZ0JBQWdCLENBQUMsS0FBYztJQUMzQyxPQUFPLFlBQVksQ0FBQyxLQUFLLENBQUMsQ0FBQyxDQUFDLENBQUUsS0FBNEIsQ0FBQyxDQUFDLENBQUMsRUFBRSxDQUFDLGVBQWUsQ0FBQyxLQUFLLENBQUMsQ0FBQyxDQUFDO0FBQzVGLENBQUM7QUFFRCxNQUFNLENBQUMsTUFBTSxZQUFZLEdBQUcsQ0FBSSxLQUF3QixFQUFpQixFQUFFO0lBQ3ZFLE9BQU8sWUFBWSxDQUFDLEtBQUssQ0FBQyxDQUFDLENBQUMsQ0FBRSxLQUF1QixDQUFDLENBQUMsQ0FBQyxFQUFFLENBQUMsS0FBSyxDQUFDLENBQUM7QUFDdEUsQ0FBQyxDQUFDO0FBRUYsTUFBTSxDQUFDLE1BQU0sY0FBYyxHQUFHLENBQUMsS0FBYyxFQUFVLEVBQUU7SUFDckQsSUFBSSxPQUFPLEtBQUssS0FBSyxRQUFRLEVBQUUsQ0FBQztRQUM1QixPQUFPLEtBQUssQ0FBQztJQUNqQixDQUFDO1NBQU0sSUFBSSxPQUFPLEtBQUssS0FBSyxRQUFRLEVBQUUsQ0FBQztRQUNuQyxNQUFNLEdBQUcsR0FBRyxDQUFDLEtBQUssQ0FBQztRQUNuQixJQUFJLENBQUMsS0FBSyxDQUFDLEdBQUcsQ0FBQyxFQUFFLENBQUM7WUFDZCxPQUFPLEdBQUcsQ0FBQztRQUNmLENBQUM7UUFDRCxNQUFNLElBQUksb0JBQW9CLENBQUMsK0RBQStELEtBQUssRUFBRSxDQUFDLENBQUM7SUFDM0csQ0FBQztTQUFNLENBQUM7UUFDSixNQUFNLElBQUksb0JBQW9CLENBQUMsMkJBQTJCLEtBQUssRUFBRSxDQUFDLENBQUM7SUFDdkUsQ0FBQztBQUNMLENBQUMsQ0FBQztBQUVGLE1BQU0sQ0FBQyxNQUFNLGNBQWMsR0FBRyxDQUFDLEtBQWMsRUFBVSxFQUFFO0lBQ3JELElBQUksT0FBTyxLQUFLLEtBQUssUUFBUSxFQUFFLENBQUM7UUFDNUIsT0FBTyxLQUFLLENBQUM7SUFDakIsQ0FBQztTQUFNLENBQUM7UUFDSixNQUFNLElBQUksb0JBQW9CLENBQUMsMkJBQTJCLEtBQUssRUFBRSxDQUFDLENBQUM7SUFDdkUsQ0FBQztBQUNMLENBQUMsQ0FBQztBQUVGLE1BQU0sQ0FBQyxNQUFNLGVBQWUsR0FBRyxDQUFDLEtBQWMsRUFBVSxFQUFFO0lBQ3RELElBQUksT0FBTyxLQUFLLEtBQUssV0FBVyxFQUFFLENBQUM7UUFDL0IsTUFBTSxJQUFJLG9CQUFvQixDQUFDLDBCQUEwQixLQUFLLEVBQUUsQ0FBQyxDQUFDO0lBQ3RFLENBQUM7U0FBTSxDQUFDO1FBQ0osT0FBTyxLQUFLLENBQUM7SUFDakIsQ0FBQztBQUNMLENBQUMsQ0FBQztBQUVGLE1BQU0sQ0FBQyxNQUFNLGNBQWMsR0FBRyxDQUFJLEtBQWtCLEVBQUssRUFBRTtJQUN2RCxJQUFJLE9BQU8sS0FBSyxLQUFLLFdBQVcsSUFBSSxLQUFLLEtBQUssSUFBSSxFQUFFLENBQUM7UUFDakQsTUFBTSxJQUFJLG9CQUFvQixDQUFDLGlDQUFpQyxLQUFLLEVBQUUsQ0FBQyxDQUFDO0lBQzdFLENBQUM7U0FBTSxDQUFDO1FBQ0osT0FBTyxLQUFLLENBQUM7SUFDakIsQ0FBQztBQUNMLENBQUMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7Ym9vbGVhbkF0dHJpYnV0ZSwgbnVtYmVyQXR0cmlidXRlfSBmcm9tICdAYW5ndWxhci9jb3JlJztcblxuaW1wb3J0IHtPYnNlcnZhYmxlLCBpc09ic2VydmFibGUsIG9mfSBmcm9tICdyeGpzJztcblxuaW1wb3J0IHtDb21tb25zSW50ZXJuYWxFcnJvcn0gZnJvbSAnLi4vZXJyb3IvZXJyb3IubW9kZWwnO1xuaW1wb3J0IHtJZFR5cGUsIE51bGxhYmxlfSBmcm9tICcuL3R5cGUtaGVscGVycyc7XG5cbmV4cG9ydCBmdW5jdGlvbiBib29sZWFuJEF0dHJpYnV0ZSh2YWx1ZTogdW5rbm93bik6IE9ic2VydmFibGU8Ym9vbGVhbj4ge1xuICAgIHJldHVybiBpc09ic2VydmFibGUodmFsdWUpID8gKHZhbHVlIGFzIE9ic2VydmFibGU8Ym9vbGVhbj4pIDogb2YoYm9vbGVhbkF0dHJpYnV0ZSh2YWx1ZSkpO1xufVxuXG5leHBvcnQgZnVuY3Rpb24gbnVtYmVyJEF0dHJpYnV0ZSh2YWx1ZTogdW5rbm93bik6IE9ic2VydmFibGU8bnVtYmVyPiB7XG4gICAgcmV0dXJuIGlzT2JzZXJ2YWJsZSh2YWx1ZSkgPyAodmFsdWUgYXMgT2JzZXJ2YWJsZTxudW1iZXI+KSA6IG9mKG51bWJlckF0dHJpYnV0ZSh2YWx1ZSkpO1xufVxuXG5leHBvcnQgY29uc3QgdG9PYnNlcnZhYmxlID0gPFQ+KHZhbHVlOiBUIHwgT2JzZXJ2YWJsZTxUPik6IE9ic2VydmFibGU8VD4gPT4ge1xuICAgIHJldHVybiBpc09ic2VydmFibGUodmFsdWUpID8gKHZhbHVlIGFzIE9ic2VydmFibGU8VD4pIDogb2YodmFsdWUpO1xufTtcblxuZXhwb3J0IGNvbnN0IGl0ZW1JZFRvTnVtYmVyID0gKHZhbHVlPzogSWRUeXBlKTogbnVtYmVyID0+IHtcbiAgICBpZiAodHlwZW9mIHZhbHVlID09PSAnbnVtYmVyJykge1xuICAgICAgICByZXR1cm4gdmFsdWU7XG4gICAgfSBlbHNlIGlmICh0eXBlb2YgdmFsdWUgPT09ICdzdHJpbmcnKSB7XG4gICAgICAgIGNvbnN0IG51bSA9ICt2YWx1ZTtcbiAgICAgICAgaWYgKCFpc05hTihudW0pKSB7XG4gICAgICAgICAgICByZXR1cm4gbnVtO1xuICAgICAgICB9XG4gICAgICAgIHRocm93IG5ldyBDb21tb25zSW50ZXJuYWxFcnJvcihgSXRlbUlkIGlzIGEgc3RyaW5nLCBidXQgY291bGQgbm90IGJlIHRyYW5zZm9ybWVkIHRvIG51bWJlcjogJHt2YWx1ZX1gKTtcbiAgICB9IGVsc2Uge1xuICAgICAgICB0aHJvdyBuZXcgQ29tbW9uc0ludGVybmFsRXJyb3IoYEl0ZW1JZCBpcyBub3QgYSBudW1iZXI6ICR7dmFsdWV9YCk7XG4gICAgfVxufTtcblxuZXhwb3J0IGNvbnN0IGl0ZW1JZFRvU3RyaW5nID0gKHZhbHVlPzogSWRUeXBlKTogc3RyaW5nID0+IHtcbiAgICBpZiAodHlwZW9mIHZhbHVlID09PSAnc3RyaW5nJykge1xuICAgICAgICByZXR1cm4gdmFsdWU7XG4gICAgfSBlbHNlIHtcbiAgICAgICAgdGhyb3cgbmV3IENvbW1vbnNJbnRlcm5hbEVycm9yKGBJdGVtSWQgaXMgbm90IGEgc3RyaW5nOiAke3ZhbHVlfWApO1xuICAgIH1cbn07XG5cbmV4cG9ydCBjb25zdCBpdGVtSWRUb0RlZmluZWQgPSAodmFsdWU/OiBJZFR5cGUpOiBJZFR5cGUgPT4ge1xuICAgIGlmICh0eXBlb2YgdmFsdWUgPT09ICd1bmRlZmluZWQnKSB7XG4gICAgICAgIHRocm93IG5ldyBDb21tb25zSW50ZXJuYWxFcnJvcihgSXRlbUlkIGlzIG5vdCBkZWZpbmVkOiAke3ZhbHVlfWApO1xuICAgIH0gZWxzZSB7XG4gICAgICAgIHJldHVybiB2YWx1ZTtcbiAgICB9XG59O1xuXG5leHBvcnQgY29uc3QgdmFsdWVUb0RlZmluZWQgPSA8VD4odmFsdWU6IE51bGxhYmxlPFQ+KTogVCA9PiB7XG4gICAgaWYgKHR5cGVvZiB2YWx1ZSA9PT0gJ3VuZGVmaW5lZCcgfHwgdmFsdWUgPT09IG51bGwpIHtcbiAgICAgICAgdGhyb3cgbmV3IENvbW1vbnNJbnRlcm5hbEVycm9yKGBWYWx1ZSBpcyBudWxsIG9yIG5vdCBkZWZpbmVkOiAke3ZhbHVlfWApO1xuICAgIH0gZWxzZSB7XG4gICAgICAgIHJldHVybiB2YWx1ZTtcbiAgICB9XG59O1xuIl19

package/esm2022/core/helpers/date.mjs

@@ -0,0 +1,119 @@
+const ngPrimerFormatSupported = [/d{1,2}/g, /E{1,5}/g, /c{1,5}/g, /M{1,5}/g, /L{1,5}/g, /y{1,4}/g, /Y{1,4}/g];
+const ngPrimeFormatOther = [/G{1,5}/g, /w{1,2}/g, /W/g, /a{1,5}/g, /B{1,5}/g, /b{1,5}/g, /h{1,2}/g, /H{1,2}/g, /m{1,2}/g, /s{1,2}/g, /S{1,3}/g, /z{1,4}/g, /Z{1,5}/g, /O{1,4}/g];
+const ngPrimerFormatMap = {
+    // days
+    d: 'd',
+    dd: 'dd',
+    E: 'D',
+    EE: 'D',
+    EEE: 'D',
+    EEEE: 'DD',
+    EEEEE: 'D',
+    EEEEEE: 'D',
+    c: 'd',
+    cc: 'dd',
+    ccc: 'D',
+    cccc: 'DD',
+    ccccc: 'D',
+    cccccc: 'D',
+    // months
+    M: 'm',
+    MM: 'mm',
+    MMM: 'M',
+    MMMM: 'MM',
+    MMMMM: 'M',
+    L: 'm',
+    LL: 'mm',
+    LLL: 'M',
+    LLLL: 'MM',
+    LLLLL: 'M',
+    // year
+    y: 'y',
+    yy: 'y',
+    yyy: 'yy',
+    yyyy: 'yy',
+    Y: 'y',
+    YY: 'y',
+    YYY: 'yy',
+    YYYY: 'yy'
+};
+function padNumber(num, size = 2) {
+    let str = String(num);
+    while (str.length < size) {
+        str = '0' + str;
+    }
+    return str;
+}
+export function dateToIsoString(value, type = 'date-time', dateTimeOpts = {}) {
+    if (typeof value === 'string') {
+        value = new Date(value);
+    }
+    if (typeof value === 'number') {
+        value = new Date(value);
+    }
+    if (!(value instanceof Date)) {
+        return null;
+    }
+    if (type === 'date') {
+        // date only, no time part (and timezone, millis, utc does not matter ...)
+        return value.getFullYear() + '-' + padNumber(value.getMonth() + 1) + '-' + padNumber(value.getDate());
+    }
+    if (dateTimeOpts.utc) {
+        let str = value.toISOString();
+        if (dateTimeOpts.noMillis) {
+            const dotIdx = str.lastIndexOf('.');
+            str = str.substring(0, dotIdx) + str.substring(dotIdx + 4, str.length);
+        }
+        if (dateTimeOpts.noTimezone) {
+            str = str.substring(0, str.length - 1);
+        }
+        return str;
+    }
+    else {
+        let base = value.getFullYear() +
+            '-' +
+            padNumber(value.getMonth() + 1) +
+            '-' +
+            padNumber(value.getDate()) +
+            'T' +
+            padNumber(value.getHours()) +
+            ':' +
+            padNumber(value.getMinutes()) +
+            ':' +
+            padNumber(value.getSeconds());
+        if (!dateTimeOpts.noMillis) {
+            base += '.' + padNumber(value.getMilliseconds());
+        }
+        if (!dateTimeOpts.noTimezone) {
+            const tzo = -value.getTimezoneOffset(), dif = tzo >= 0 ? '+' : '-';
+            base = base + (dif + padNumber(Math.floor(Math.abs(tzo) / 60)) + ':' + padNumber(Math.abs(tzo) % 60));
+        }
+        return base;
+    }
+}
+export function fromAngularDateFormatToPrime(ngDateFormat) {
+    let primeDateFormat = ngDateFormat;
+    for (const regex of ngPrimeFormatOther) {
+        primeDateFormat = primeDateFormat.replace(regex, ' ');
+    }
+    for (const regex of ngPrimerFormatSupported) {
+        const matches = [...primeDateFormat.matchAll(regex)].reverse();
+        for (const match of matches) {
+            if (match.index) {
+                const matchStr = match[0];
+                const replacement = ngPrimerFormatMap[matchStr] ?? match[0];
+                primeDateFormat = primeDateFormat.substring(0, match.index) + replacement + primeDateFormat.substring(match.index + matchStr.length);
+            }
+        }
+    }
+    primeDateFormat = primeDateFormat.replace(/\s+\W\s+/g, ' ');
+    primeDateFormat = primeDateFormat.replace(/\s\s+/g, ' ');
+    return primeDateFormat.trim();
+}
+export function angularDateFormatHasTime(ngDateFormat) {
+    return /[hHmsS]/.test(ngDateFormat);
+}
+export function angularDateFormatHasSeconds(ngDateFormat) {
+    return /[sS]/.test(ngDateFormat);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"date.js","sourceRoot":"","sources":["../../../../core/src/helpers/date.ts"],"names":[],"mappings":"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","sourcesContent":["export type toIsoStringTypeOptType = 'date' | 'date-time' | 'dateTime';\nexport type toIsoStringDateTimeOptsType = {utc?: boolean; noTimezone?: boolean; noMillis?: boolean};\n\nconst ngPrimerFormatSupported = [/d{1,2}/g, /E{1,5}/g, /c{1,5}/g, /M{1,5}/g, /L{1,5}/g, /y{1,4}/g, /Y{1,4}/g];\nconst ngPrimeFormatOther = [/G{1,5}/g, /w{1,2}/g, /W/g, /a{1,5}/g, /B{1,5}/g, /b{1,5}/g, /h{1,2}/g, /H{1,2}/g, /m{1,2}/g, /s{1,2}/g, /S{1,3}/g, /z{1,4}/g, /Z{1,5}/g, /O{1,4}/g];\nconst ngPrimerFormatMap = {\n    // days\n    d: 'd',\n    dd: 'dd',\n    E: 'D',\n    EE: 'D',\n    EEE: 'D',\n    EEEE: 'DD',\n    EEEEE: 'D',\n    EEEEEE: 'D',\n    c: 'd',\n    cc: 'dd',\n    ccc: 'D',\n    cccc: 'DD',\n    ccccc: 'D',\n    cccccc: 'D',\n    // months\n    M: 'm',\n    MM: 'mm',\n    MMM: 'M',\n    MMMM: 'MM',\n    MMMMM: 'M',\n    L: 'm',\n    LL: 'mm',\n    LLL: 'M',\n    LLLL: 'MM',\n    LLLLL: 'M',\n    // year\n    y: 'y',\n    yy: 'y',\n    yyy: 'yy',\n    yyyy: 'yy',\n    Y: 'y',\n    YY: 'y',\n    YYY: 'yy',\n    YYYY: 'yy'\n};\n\nfunction padNumber(num: number, size = 2) {\n    let str = String(num);\n    while (str.length < size) {\n        str = '0' + str;\n    }\n    return str;\n}\n\nexport function dateToIsoString(value: string | number | Date, type?: 'date'): string;\nexport function dateToIsoString(value: string | number | Date, type: 'date-time' | 'dateTime', dateTimeOpts?: toIsoStringDateTimeOptsType): string;\nexport function dateToIsoString(value: undefined | null | unknown, type?: 'date'): null;\nexport function dateToIsoString(value: undefined | null | unknown, type: 'date-time' | 'dateTime', dateTimeOpts?: toIsoStringDateTimeOptsType): null;\nexport function dateToIsoString(value: unknown, type?: toIsoStringTypeOptType, dateTimeOpts?: toIsoStringDateTimeOptsType): string | null;\nexport function dateToIsoString(value: unknown, type: toIsoStringTypeOptType = 'date-time', dateTimeOpts: toIsoStringDateTimeOptsType = {}): string | null {\n    if (typeof value === 'string') {\n        value = new Date(value);\n    }\n    if (typeof value === 'number') {\n        value = new Date(value);\n    }\n    if (!(value instanceof Date)) {\n        return null;\n    }\n    if (type === 'date') {\n        // date only, no time part (and timezone, millis, utc does not matter ...)\n        return value.getFullYear() + '-' + padNumber(value.getMonth() + 1) + '-' + padNumber(value.getDate());\n    }\n    if (dateTimeOpts.utc) {\n        let str = value.toISOString();\n        if (dateTimeOpts.noMillis) {\n            const dotIdx = str.lastIndexOf('.');\n            str = str.substring(0, dotIdx) + str.substring(dotIdx + 4, str.length);\n        }\n        if (dateTimeOpts.noTimezone) {\n            str = str.substring(0, str.length - 1);\n        }\n        return str;\n    } else {\n        let base =\n            value.getFullYear() +\n            '-' +\n            padNumber(value.getMonth() + 1) +\n            '-' +\n            padNumber(value.getDate()) +\n            'T' +\n            padNumber(value.getHours()) +\n            ':' +\n            padNumber(value.getMinutes()) +\n            ':' +\n            padNumber(value.getSeconds());\n\n        if (!dateTimeOpts.noMillis) {\n            base += '.' + padNumber(value.getMilliseconds());\n        }\n        if (!dateTimeOpts.noTimezone) {\n            const tzo = -value.getTimezoneOffset(),\n                dif = tzo >= 0 ? '+' : '-';\n\n            base = base + (dif + padNumber(Math.floor(Math.abs(tzo) / 60)) + ':' + padNumber(Math.abs(tzo) % 60));\n        }\n\n        return base;\n    }\n}\n\nexport function fromAngularDateFormatToPrime(ngDateFormat: string): string {\n    let primeDateFormat = ngDateFormat;\n    for (const regex of ngPrimeFormatOther) {\n        primeDateFormat = primeDateFormat.replace(regex, ' ');\n    }\n    for (const regex of ngPrimerFormatSupported) {\n        const matches = [...primeDateFormat.matchAll(regex)].reverse();\n        for (const match of matches) {\n            if (match.index) {\n                const matchStr = match[0];\n                const replacement = ngPrimerFormatMap[matchStr as keyof object] ?? match[0];\n                primeDateFormat = primeDateFormat.substring(0, match.index) + replacement + primeDateFormat.substring(match.index + matchStr.length);\n            }\n        }\n    }\n    primeDateFormat = primeDateFormat.replace(/\\s+\\W\\s+/g, ' ');\n    primeDateFormat = primeDateFormat.replace(/\\s\\s+/g, ' ');\n\n    return primeDateFormat.trim();\n}\n\nexport function angularDateFormatHasTime(ngDateFormat: string): boolean {\n    return /[hHmsS]/.test(ngDateFormat);\n}\n\nexport function angularDateFormatHasSeconds(ngDateFormat: string): boolean {\n    return /[sS]/.test(ngDateFormat);\n}\n"]}

package/esm2022/core/helpers/notification.mjs

@@ -0,0 +1,6 @@
+export function toastMessage(messageService, title, message, severity = 'success', icon) {
+    const notification = { severity: severity, summary: title, detail: message, life: severity === 'error' ? 10000 : 5000, icon: icon };
+    messageService.add(notification);
+    return notification;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibm90aWZpY2F0aW9uLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vY29yZS9zcmMvaGVscGVycy9ub3RpZmljYXRpb24udHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBRUEsTUFBTSxVQUFVLFlBQVksQ0FBQyxjQUE4QixFQUFFLEtBQWMsRUFBRSxPQUFnQixFQUFFLFdBQXlDLFNBQVMsRUFBRSxJQUFhO0lBQzVKLE1BQU0sWUFBWSxHQUFZLEVBQUMsUUFBUSxFQUFFLFFBQVEsRUFBRSxPQUFPLEVBQUUsS0FBSyxFQUFFLE1BQU0sRUFBRSxPQUFPLEVBQUUsSUFBSSxFQUFFLFFBQVEsS0FBSyxPQUFPLENBQUMsQ0FBQyxDQUFDLEtBQUssQ0FBQyxDQUFDLENBQUMsSUFBSSxFQUFFLElBQUksRUFBRSxJQUFJLEVBQUMsQ0FBQztJQUMzSSxjQUFjLENBQUMsR0FBRyxDQUFDLFlBQVksQ0FBQyxDQUFDO0lBQ2pDLE9BQU8sWUFBWSxDQUFDO0FBQ3hCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQge01lc3NhZ2UsIE1lc3NhZ2VTZXJ2aWNlfSBmcm9tICdwcmltZW5nL2FwaSc7XG5cbmV4cG9ydCBmdW5jdGlvbiB0b2FzdE1lc3NhZ2UobWVzc2FnZVNlcnZpY2U6IE1lc3NhZ2VTZXJ2aWNlLCB0aXRsZT86IHN0cmluZywgbWVzc2FnZT86IHN0cmluZywgc2V2ZXJpdHk6ICdzdWNjZXNzJyB8ICd3YXJuJyB8ICdlcnJvcicgPSAnc3VjY2VzcycsIGljb24/OiBzdHJpbmcpOiBNZXNzYWdlIHtcbiAgICBjb25zdCBub3RpZmljYXRpb246IE1lc3NhZ2UgPSB7c2V2ZXJpdHk6IHNldmVyaXR5LCBzdW1tYXJ5OiB0aXRsZSwgZGV0YWlsOiBtZXNzYWdlLCBsaWZlOiBzZXZlcml0eSA9PT0gJ2Vycm9yJyA/IDEwMDAwIDogNTAwMCwgaWNvbjogaWNvbn07XG4gICAgbWVzc2FnZVNlcnZpY2UuYWRkKG5vdGlmaWNhdGlvbik7XG4gICAgcmV0dXJuIG5vdGlmaWNhdGlvbjtcbn1cbiJdfQ==