@alauda-fe/common 1.0.0-hotfix-znx-3.16.1-1

package/esm2022/core/guards/feature.guard.mjs

@@ -0,0 +1,58 @@
+import { Inject, Injectable, InjectionToken, Optional } from '@angular/core';
+import { map } from 'rxjs';
+import { FeatureGateService } from '../services/feature-gate.service';
+import { SilentlyNavigateService } from '../services/silently-navigate.service';
+import * as i0 from "@angular/core";
+import * as i1 from "../services/feature-gate.service";
+import * as i2 from "../services/silently-navigate.service";
+export const DEFAULT_FEATURE_FORBIDDEN_URL = 'feature-forbidden';
+export const GET_CURRENT_CLUSTER = new InjectionToken('Get current cluster function');
+/**
+ * ```ts
+ * data: {
+ *  path: 'home',
+ *  canActivate: [ FeatureGuard ],
+ *  data: { featureName: 'ace3', guard_url: 'xxx'  }
+ * }
+ * ```
+ */
+export class FeatureGuard {
+    constructor(featureGate, silentlyNavigate, getCluster) {
+        this.featureGate = featureGate;
+        this.silentlyNavigate = silentlyNavigate;
+        this.getCluster = getCluster;
+    }
+    canActivateChild(childRoute, state) {
+        return this.canActivate(childRoute, state);
+    }
+    canActivate(route, state) {
+        const data = {
+            featureName: '',
+            guard_url: DEFAULT_FEATURE_FORBIDDEN_URL,
+            ...route.data,
+        };
+        let currentCluster;
+        if (this.getCluster) {
+            currentCluster = this.getCluster(route);
+        }
+        return this.featureGate.isEnabled(data.featureName, currentCluster).pipe(map(enabled => {
+            if (enabled)
+                return true;
+            const errorUrl = `${data.guard_url}/${data.featureName}`;
+            this.silentlyNavigate.navigate(state.url, errorUrl);
+            return false;
+        }));
+    }
+    static { this.ɵfac = function FeatureGuard_Factory(t) { return new (t || FeatureGuard)(i0.ɵɵinject(i1.FeatureGateService), i0.ɵɵinject(i2.SilentlyNavigateService), i0.ɵɵinject(GET_CURRENT_CLUSTER, 8)); }; }
+    static { this.ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: FeatureGuard, factory: FeatureGuard.ɵfac, providedIn: 'root' }); }
+}
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(FeatureGuard, [{
+        type: Injectable,
+        args: [{ providedIn: 'root' }]
+    }], function () { return [{ type: i1.FeatureGateService }, { type: i2.SilentlyNavigateService }, { type: undefined, decorators: [{
+                type: Inject,
+                args: [GET_CURRENT_CLUSTER]
+            }, {
+                type: Optional
+            }] }]; }, null); })();
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/core/guards/intercept-deactivate.guard.mjs

@@ -0,0 +1,40 @@
+import { Injectable, Injector } from '@angular/core';
+import { from, Observable, of, switchMap } from 'rxjs';
+import { InterceptDeactivateService } from '../services/intercept-deactivate.service';
+import * as i0 from "@angular/core";
+export const ESCAPE_DEACTIVATE_GUARD = '__ESCAPE_DEACTIVATE_GUARD__';
+export const CURR_ESCAPE_DEACTIVATE_GUARD = '__CURR_ESCAPE_DEACTIVATE_GUARD__';
+export class InterceptDeactivateGuard {
+    constructor(injector) {
+        this.injector = injector;
+    }
+    canDeactivate(component, currentRoute, currentState, nextState) {
+        let { canDeactivate } = component;
+        if (typeof canDeactivate === 'function') {
+            canDeactivate = canDeactivate();
+        }
+        const result$ = canDeactivate instanceof Observable || canDeactivate instanceof Promise
+            ? from(canDeactivate)
+            : of(!!canDeactivate);
+        return result$.pipe(switchMap(canDeactivate => {
+            if (canDeactivate ||
+                CURR_ESCAPE_DEACTIVATE_GUARD === currentState.root.fragment ||
+                ESCAPE_DEACTIVATE_GUARD === nextState.root.fragment) {
+                return of(true);
+            }
+            return this.injector.get(InterceptDeactivateService).intercept({
+                title: currentRoute.data.interceptDeactivateTitle,
+                content: currentRoute.data.interceptDeactivateContent,
+                context: component,
+                errorFallback: false,
+            });
+        }));
+    }
+    static { this.ɵfac = function InterceptDeactivateGuard_Factory(t) { return new (t || InterceptDeactivateGuard)(i0.ɵɵinject(i0.Injector)); }; }
+    static { this.ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: InterceptDeactivateGuard, factory: InterceptDeactivateGuard.ɵfac, providedIn: 'root' }); }
+}
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(InterceptDeactivateGuard, [{
+        type: Injectable,
+        args: [{ providedIn: 'root' }]
+    }], function () { return [{ type: i0.Injector }]; }, null); })();
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/core/guards/leave-edit-page.guard.mjs

@@ -0,0 +1,32 @@
+import { DialogService } from '@alauda/ui';
+import { Injectable } from '@angular/core';
+import { from, of, map } from 'rxjs';
+import { TranslateService } from '../../translate/public-api';
+import { ESCAPE_DEACTIVATE_CHECK } from '../constants/public-api';
+import { skipError } from '../utils/public-api';
+import * as i0 from "@angular/core";
+import * as i1 from "@alauda/ui";
+import * as i2 from "../../translate/public-api";
+export class EditPageLeaveGuardService {
+    constructor(dialogService, translate) {
+        this.dialogService = dialogService;
+        this.translate = translate;
+    }
+    canDeactivate(_, _ars, _rss, nextState) {
+        if (nextState.root.fragment === ESCAPE_DEACTIVATE_CHECK) {
+            return of(true);
+        }
+        return from(this.dialogService.confirm({
+            title: this.translate.get('create_page_leave_tip'),
+            content: this.translate.get('create_page_leave_content'),
+            confirmText: this.translate.get('confirm'),
+            cancelText: this.translate.get('cancel'),
+        })).pipe(map(() => true), skipError(false));
+    }
+    static { this.ɵfac = function EditPageLeaveGuardService_Factory(t) { return new (t || EditPageLeaveGuardService)(i0.ɵɵinject(i1.DialogService), i0.ɵɵinject(i2.TranslateService)); }; }
+    static { this.ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: EditPageLeaveGuardService, factory: EditPageLeaveGuardService.ɵfac }); }
+}
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(EditPageLeaveGuardService, [{
+        type: Injectable
+    }], function () { return [{ type: i1.DialogService }, { type: i2.TranslateService }]; }, null); })();
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/core/guards/project-namespace.guard.mjs

@@ -0,0 +1,70 @@
+import { Injectable } from '@angular/core';
+import { Router, } from '@angular/router';
+import { map } from 'rxjs';
+import { AuthorizationStateService } from '../../authorization/state.service';
+import { getWorkspaceParams } from '../../business/resource-select/utils';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/router";
+import * as i2 from "../../authorization/state.service";
+export class ProjectNamespaceGuard {
+    constructor(router, auth) {
+        this.router = router;
+        this.auth = auth;
+    }
+    canActivate(route, state) {
+        if (route.queryParams.project) {
+            return true;
+        }
+        return this.auth.getAccountInfo().pipe(map(({ email }) => {
+            const params = getWorkspaceParams(email);
+            if (typeof route.data.getWorkspaceUrl === 'function') {
+                const workspaceUrl = route.data.getWorkspaceUrl(params, route);
+                if (workspaceUrl) {
+                    return this.router.createUrlTree(Array.isArray(workspaceUrl) ? workspaceUrl : [workspaceUrl]);
+                }
+            }
+            if (params?.project) {
+                return this.router.createUrlTree([state.url.split('?')[0]], {
+                    queryParams: { ...state.root.queryParams, project: params.project },
+                });
+            }
+        }));
+    }
+    canActivateChild(route, state) {
+        return this.canActivate(route, state);
+    }
+    static { this.ɵfac = function ProjectNamespaceGuard_Factory(t) { return new (t || ProjectNamespaceGuard)(i0.ɵɵinject(i1.Router), i0.ɵɵinject(i2.AuthorizationStateService)); }; }
+    static { this.ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: ProjectNamespaceGuard, factory: ProjectNamespaceGuard.ɵfac, providedIn: 'root' }); }
+}
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(ProjectNamespaceGuard, [{
+        type: Injectable,
+        args: [{ providedIn: 'root' }]
+    }], function () { return [{ type: i1.Router }, { type: i2.AuthorizationStateService }]; }, null); })();
+export class ProjectGuard {
+    constructor(router, auth) {
+        this.router = router;
+        this.auth = auth;
+    }
+    canActivate(route, _state) {
+        return this.auth.getAccountInfo().pipe(map(({ email }) => {
+            const params = getWorkspaceParams(email);
+            if (typeof route.data.getWorkspaceUrl === 'function') {
+                const workspaceUrl = route.data.getWorkspaceUrl(params);
+                if (workspaceUrl) {
+                    return this.router.createUrlTree(Array.isArray(workspaceUrl) ? workspaceUrl : [workspaceUrl]);
+                }
+            }
+            return true;
+        }));
+    }
+    canActivateChild(route, state) {
+        return this.canActivate(route, state);
+    }
+    static { this.ɵfac = function ProjectGuard_Factory(t) { return new (t || ProjectGuard)(i0.ɵɵinject(i1.Router), i0.ɵɵinject(i2.AuthorizationStateService)); }; }
+    static { this.ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: ProjectGuard, factory: ProjectGuard.ɵfac, providedIn: 'root' }); }
+}
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(ProjectGuard, [{
+        type: Injectable,
+        args: [{ providedIn: 'root' }]
+    }], function () { return [{ type: i1.Router }, { type: i2.AuthorizationStateService }]; }, null); })();
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/core/guards/public-api.mjs

@@ -0,0 +1,5 @@
+export * from './feature.guard';
+export * from './intercept-deactivate.guard';
+export * from './project-namespace.guard';
+export * from './leave-edit-page.guard';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL2xpYnMvY29tbW9uL3NyYy9jb3JlL2d1YXJkcy9wdWJsaWMtYXBpLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsaUJBQWlCLENBQUM7QUFDaEMsY0FBYyw4QkFBOEIsQ0FBQztBQUM3QyxjQUFjLDJCQUEyQixDQUFDO0FBQzFDLGNBQWMseUJBQXlCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL2ZlYXR1cmUuZ3VhcmQnO1xuZXhwb3J0ICogZnJvbSAnLi9pbnRlcmNlcHQtZGVhY3RpdmF0ZS5ndWFyZCc7XG5leHBvcnQgKiBmcm9tICcuL3Byb2plY3QtbmFtZXNwYWNlLmd1YXJkJztcbmV4cG9ydCAqIGZyb20gJy4vbGVhdmUtZWRpdC1wYWdlLmd1YXJkJztcbiJdfQ==

package/esm2022/core/module.mjs

@@ -0,0 +1,145 @@
+/**
+ * @packageDocumentation
+ * @module utils
+ */
+import { CommonModule } from '@angular/common';
+import { NgModule } from '@angular/core';
+import { ReactiveFormsModule } from '@angular/forms';
+import { EffectDirectiveModule } from '../effect-directive/public-api';
+import { PurePipeModule } from '../scm/public-api';
+import { DisabledDirective } from './directives/disabled.directive';
+import { FeatureGateDirective } from './directives/feature-gate.directive';
+import { FormItemMarginEffectDirective } from './directives/last-form-item.directive';
+import { PageHeaderContentDirective } from './directives/page-header-content.directive';
+import { ClickOutsideDirective, InterceptDeactivateDirective, ScrollBorderObserverDirective, ScrollToFirstInvalidDirective, ScrollToFirstInvalidMarkerDirective, } from './directives/public-api';
+import { ReadonlyFieldDirective, SpanComponent, } from './directives/readonly-field.directive';
+import { ResizeDirective } from './directives/resize.directive';
+import { CrontabNextPipe } from './pipes/crontab-next.pipe';
+import { FieldNotAvailablePipe } from './pipes/field-not-available.pipe';
+import { ImgHeaderPipe } from './pipes/img-header.pipe';
+import { ImgThemePipe } from './pipes/img-theme.pipe';
+import { K8sUtilPipeModule } from './pipes/k8s-util.pipe.module';
+import { ParseJsonTranslatePipe } from './pipes/parse-json-translate.pipe';
+import { CronHumanReadablePipe, LocaleTransformPipe, MarkedPipe, RelativeTimePipe, SanitizePipe, StandardDatePipe, StandardTimePipe, ThemeTransformPipe, TimezoneDisplayPipe, } from './pipes/public-api';
+import { SafePipe } from './pipes/safe.pipe';
+import * as i0 from "@angular/core";
+const STANDS = [
+    ReadonlyFieldDirective,
+    PurePipeModule,
+    ParseJsonTranslatePipe,
+    FieldNotAvailablePipe,
+    ImgHeaderPipe,
+    ImgThemePipe,
+    SafePipe,
+    SanitizePipe,
+    RelativeTimePipe,
+    PageHeaderContentDirective,
+    StandardTimePipe,
+    ScrollToFirstInvalidDirective,
+    InterceptDeactivateDirective,
+    DisabledDirective,
+    ClickOutsideDirective,
+    ScrollBorderObserverDirective,
+    ResizeDirective,
+];
+const PIPES = [
+    // time pipes
+    StandardDatePipe,
+    CrontabNextPipe,
+    MarkedPipe,
+    LocaleTransformPipe,
+    ThemeTransformPipe,
+    TimezoneDisplayPipe,
+    CronHumanReadablePipe,
+];
+const DIRECTIVES = [
+    FeatureGateDirective,
+    ScrollToFirstInvalidMarkerDirective,
+    FormItemMarginEffectDirective,
+];
+const EXPORTABLES = [...PIPES, ...DIRECTIVES];
+const INTERNALS = [SpanComponent];
+export class CoreModule {
+    static { this.ɵfac = function CoreModule_Factory(t) { return new (t || CoreModule)(); }; }
+    static { this.ɵmod = /*@__PURE__*/ i0.ɵɵdefineNgModule({ type: CoreModule }); }
+    static { this.ɵinj = /*@__PURE__*/ i0.ɵɵdefineInjector({ imports: [CommonModule,
+            ReactiveFormsModule, PurePipeModule, K8sUtilPipeModule,
+            EffectDirectiveModule, PurePipeModule, K8sUtilPipeModule,
+            EffectDirectiveModule] }); }
+}
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(CoreModule, [{
+        type: NgModule,
+        args: [{
+                imports: [
+                    CommonModule,
+                    ReactiveFormsModule,
+                    ...STANDS,
+                    K8sUtilPipeModule,
+                    EffectDirectiveModule,
+                ],
+                declarations: [...EXPORTABLES, ...INTERNALS],
+                exports: [
+                    ...EXPORTABLES,
+                    ...STANDS,
+                    K8sUtilPipeModule,
+                    EffectDirectiveModule,
+                ],
+            }]
+    }], null, null); })();
+(function () { (typeof ngJitMode === "undefined" || ngJitMode) && i0.ɵɵsetNgModuleScope(CoreModule, { declarations: [
+        // time pipes
+        StandardDatePipe,
+        CrontabNextPipe,
+        MarkedPipe,
+        LocaleTransformPipe,
+        ThemeTransformPipe,
+        TimezoneDisplayPipe,
+        CronHumanReadablePipe, FeatureGateDirective,
+        ScrollToFirstInvalidMarkerDirective,
+        FormItemMarginEffectDirective, SpanComponent], imports: [CommonModule,
+        ReactiveFormsModule, ReadonlyFieldDirective,
+        PurePipeModule,
+        ParseJsonTranslatePipe,
+        FieldNotAvailablePipe,
+        ImgHeaderPipe,
+        ImgThemePipe,
+        SafePipe,
+        SanitizePipe,
+        RelativeTimePipe,
+        PageHeaderContentDirective,
+        StandardTimePipe,
+        ScrollToFirstInvalidDirective,
+        InterceptDeactivateDirective,
+        DisabledDirective,
+        ClickOutsideDirective,
+        ScrollBorderObserverDirective,
+        ResizeDirective, K8sUtilPipeModule,
+        EffectDirectiveModule], exports: [
+        // time pipes
+        StandardDatePipe,
+        CrontabNextPipe,
+        MarkedPipe,
+        LocaleTransformPipe,
+        ThemeTransformPipe,
+        TimezoneDisplayPipe,
+        CronHumanReadablePipe, FeatureGateDirective,
+        ScrollToFirstInvalidMarkerDirective,
+        FormItemMarginEffectDirective, ReadonlyFieldDirective,
+        PurePipeModule,
+        ParseJsonTranslatePipe,
+        FieldNotAvailablePipe,
+        ImgHeaderPipe,
+        ImgThemePipe,
+        SafePipe,
+        SanitizePipe,
+        RelativeTimePipe,
+        PageHeaderContentDirective,
+        StandardTimePipe,
+        ScrollToFirstInvalidDirective,
+        InterceptDeactivateDirective,
+        DisabledDirective,
+        ClickOutsideDirective,
+        ScrollBorderObserverDirective,
+        ResizeDirective, K8sUtilPipeModule,
+        EffectDirectiveModule] }); })();
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/core/pipes/cron-human-readable.pipe.mjs

@@ -0,0 +1,33 @@
+import { Pipe } from '@angular/core';
+import cronstrue from 'cronstrue';
+import 'cronstrue/locales/zh_CN';
+import 'cronstrue/locales/en';
+import * as i0 from "@angular/core";
+const LOCALE_SUPPORT = {
+    zh: 'zh_CN',
+    en: 'en',
+};
+export class CronHumanReadablePipe {
+    transform(cronString, locale) {
+        let humanReadableString;
+        try {
+            humanReadableString = cronstrue.toString(cronString, {
+                locale: LOCALE_SUPPORT[locale] || LOCALE_SUPPORT.en,
+                throwExceptionOnParseError: true,
+            });
+        }
+        catch {
+            humanReadableString = 'N/A';
+        }
+        return humanReadableString;
+    }
+    static { this.ɵfac = function CronHumanReadablePipe_Factory(t) { return new (t || CronHumanReadablePipe)(); }; }
+    static { this.ɵpipe = /*@__PURE__*/ i0.ɵɵdefinePipe({ name: "aclCronHumanReadable", type: CronHumanReadablePipe, pure: true }); }
+}
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(CronHumanReadablePipe, [{
+        type: Pipe,
+        args: [{
+                name: 'aclCronHumanReadable',
+            }]
+    }], null, null); })();
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/core/pipes/crontab-next.pipe.mjs

@@ -0,0 +1,62 @@
+import { Pipe, isDevMode } from '@angular/core';
+import parser from 'cron-parser';
+import dayjs from 'dayjs';
+import { TimeService } from '../services/time.service';
+import { isErrorMessage } from '../types/helpers';
+import { isCronWeekDayCorrect, isCronFieldCountCorrect, } from '../utils/cron-util';
+import * as i0 from "@angular/core";
+import * as i1 from "../services/time.service";
+export class CrontabNextPipe {
+    constructor(time) {
+        this.time = time;
+    }
+    transform(rule, step = 1, { utc, showUtc = true, format, tz = this.time.currTz, formatTz = this.time.currTz, showLocalTz = true, parseInCurrentTz = false, } = {}) {
+        let dateString = 'N/A';
+        if (!rule ||
+            !isCronFieldCountCorrect(rule) ||
+            !isCronWeekDayCorrect(rule)) {
+            return dateString;
+        }
+        try {
+            // 后端解析 crontab 表达式一定是 UTC 时间
+            // const interval = parser.parseExpression(rule, { utc: false, tz });
+            // underlord 的网络检测目前后端未按 UTC 时间解析，增加对本地时区的处理
+            // 预计 3.13 去除对网络检测的兼容
+            // Usage: apps\underlord\src\app\manage-platform\features\network-manage\trace
+            const interval = parser.parseExpression(rule, {
+                utc: !parseInCurrentTz,
+                tz,
+            });
+            let timestamp;
+            for (let i = 0; i < step; i++) {
+                timestamp = interval.next().getTime();
+            }
+            const nextDate = dayjs.utc(timestamp);
+            const tzDisplay = utc
+                ? showUtc
+                    ? ` (UTC)`
+                    : ''
+                : showLocalTz
+                    ? ` (${tz})`
+                    : '';
+            dateString =
+                this.time.format(utc ? nextDate : nextDate.tz(formatTz), format) +
+                    tzDisplay;
+        }
+        catch (err) {
+            if (isDevMode() && isErrorMessage(err) && !/invalid/i.test(err.message)) {
+                console.error(err);
+            }
+        }
+        return dateString;
+    }
+    static { this.ɵfac = function CrontabNextPipe_Factory(t) { return new (t || CrontabNextPipe)(i0.ɵɵdirectiveInject(i1.TimeService, 16)); }; }
+    static { this.ɵpipe = /*@__PURE__*/ i0.ɵɵdefinePipe({ name: "aclCrontabNext", type: CrontabNextPipe, pure: true }); }
+}
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(CrontabNextPipe, [{
+        type: Pipe,
+        args: [{
+                name: 'aclCrontabNext',
+            }]
+    }], function () { return [{ type: i1.TimeService }]; }, null); })();
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY3JvbnRhYi1uZXh0LnBpcGUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9saWJzL2NvbW1vbi9zcmMvY29yZS9waXBlcy9jcm9udGFiLW5leHQucGlwZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsSUFBSSxFQUFpQixTQUFTLEVBQUUsTUFBTSxlQUFlLENBQUM7QUFDL0QsT0FBTyxNQUFNLE1BQU0sYUFBYSxDQUFDO0FBQ2pDLE9BQU8sS0FBSyxNQUFNLE9BQU8sQ0FBQztBQUUxQixPQUFPLEVBQUUsV0FBVyxFQUFFLE1BQU0sMEJBQTBCLENBQUM7QUFDdkQsT0FBTyxFQUFFLGNBQWMsRUFBRSxNQUFNLGtCQUFrQixDQUFDO0FBQ2xELE9BQU8sRUFDTCxvQkFBb0IsRUFDcEIsdUJBQXVCLEdBQ3hCLE1BQU0sb0JBQW9CLENBQUM7OztBQUs1QixNQUFNLE9BQU8sZUFBZTtJQUMxQixZQUE2QixJQUFpQjtRQUFqQixTQUFJLEdBQUosSUFBSSxDQUFhO0lBQUcsQ0FBQztJQUVsRCxTQUFTLENBQ1AsSUFBWSxFQUNaLElBQUksR0FBRyxDQUFDLEVBQ1IsRUFDRSxHQUFHLEVBQ0gsT0FBTyxHQUFHLElBQUksRUFDZCxNQUFNLEVBQ04sRUFBRSxHQUFHLElBQUksQ0FBQyxJQUFJLENBQUMsTUFBTSxFQUNyQixRQUFRLEdBQUcsSUFBSSxDQUFDLElBQUksQ0FBQyxNQUFNLEVBQzNCLFdBQVcsR0FBRyxJQUFJLEVBQ2xCLGdCQUFnQixHQUFHLEtBQUssTUFTdEIsRUFBRTtRQUVOLElBQUksVUFBVSxHQUFHLEtBQUssQ0FBQztRQUN2QixJQUNFLENBQUMsSUFBSTtZQUNMLENBQUMsdUJBQXVCLENBQUMsSUFBSSxDQUFDO1lBQzlCLENBQUMsb0JBQW9CLENBQUMsSUFBSSxDQUFDLEVBQzNCO1lBQ0EsT0FBTyxVQUFVLENBQUM7U0FDbkI7UUFDRCxJQUFJO1lBQ0YsNkJBQTZCO1lBQzdCLHFFQUFxRTtZQUVyRSw0Q0FBNEM7WUFDNUMscUJBQXFCO1lBQ3JCLDhFQUE4RTtZQUM5RSxNQUFNLFFBQVEsR0FBRyxNQUFNLENBQUMsZUFBZSxDQUFDLElBQUksRUFBRTtnQkFDNUMsR0FBRyxFQUFFLENBQUMsZ0JBQWdCO2dCQUN0QixFQUFFO2FBQ0gsQ0FBQyxDQUFDO1lBRUgsSUFBSSxTQUFpQixDQUFDO1lBQ3RCLEtBQUssSUFBSSxDQUFDLEdBQUcsQ0FBQyxFQUFFLENBQUMsR0FBRyxJQUFJLEVBQUUsQ0FBQyxFQUFFLEVBQUU7Z0JBQzdCLFNBQVMsR0FBRyxRQUFRLENBQUMsSUFBSSxFQUFFLENBQUMsT0FBTyxFQUFFLENBQUM7YUFDdkM7WUFDRCxNQUFNLFFBQVEsR0FBRyxLQUFLLENBQUMsR0FBRyxDQUFDLFNBQVMsQ0FBQyxDQUFDO1lBRXRDLE1BQU0sU0FBUyxHQUFHLEdBQUc7Z0JBQ25CLENBQUMsQ0FBQyxPQUFPO29CQUNQLENBQUMsQ0FBQyxRQUFRO29CQUNWLENBQUMsQ0FBQyxFQUFFO2dCQUNOLENBQUMsQ0FBQyxXQUFXO29CQUNiLENBQUMsQ0FBQyxLQUFLLEVBQUUsR0FBRztvQkFDWixDQUFDLENBQUMsRUFBRSxDQUFDO1lBQ1AsVUFBVTtnQkFDUixJQUFJLENBQUMsSUFBSSxDQUFDLE1BQU0sQ0FBQyxHQUFHLENBQUMsQ0FBQyxDQUFDLFFBQVEsQ0FBQyxDQUFDLENBQUMsUUFBUSxDQUFDLEVBQUUsQ0FBQyxRQUFRLENBQUMsRUFBRSxNQUFNLENBQUM7b0JBQ2hFLFNBQVMsQ0FBQztTQUNiO1FBQUMsT0FBTyxHQUFHLEVBQUU7WUFDWixJQUFJLFNBQVMsRUFBRSxJQUFJLGNBQWMsQ0FBQyxHQUFHLENBQUMsSUFBSSxDQUFDLFVBQVUsQ0FBQyxJQUFJLENBQUMsR0FBRyxDQUFDLE9BQU8sQ0FBQyxFQUFFO2dCQUN2RSxPQUFPLENBQUMsS0FBSyxDQUFDLEdBQUcsQ0FBQyxDQUFDO2FBQ3BCO1NBQ0Y7UUFDRCxPQUFPLFVBQVUsQ0FBQztJQUNwQixDQUFDO2dGQWxFVSxlQUFlO3dGQUFmLGVBQWU7O3VGQUFmLGVBQWU7Y0FIM0IsSUFBSTtlQUFDO2dCQUNKLElBQUksRUFBRSxnQkFBZ0I7YUFDdkIiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBQaXBlLCBQaXBlVHJhbnNmb3JtLCBpc0Rldk1vZGUgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcbmltcG9ydCBwYXJzZXIgZnJvbSAnY3Jvbi1wYXJzZXInO1xuaW1wb3J0IGRheWpzIGZyb20gJ2RheWpzJztcblxuaW1wb3J0IHsgVGltZVNlcnZpY2UgfSBmcm9tICcuLi9zZXJ2aWNlcy90aW1lLnNlcnZpY2UnO1xuaW1wb3J0IHsgaXNFcnJvck1lc3NhZ2UgfSBmcm9tICcuLi90eXBlcy9oZWxwZXJzJztcbmltcG9ydCB7XG4gIGlzQ3JvbldlZWtEYXlDb3JyZWN0LFxuICBpc0Nyb25GaWVsZENvdW50Q29ycmVjdCxcbn0gZnJvbSAnLi4vdXRpbHMvY3Jvbi11dGlsJztcblxuQFBpcGUoe1xuICBuYW1lOiAnYWNsQ3JvbnRhYk5leHQnLFxufSlcbmV4cG9ydCBjbGFzcyBDcm9udGFiTmV4dFBpcGUgaW1wbGVtZW50cyBQaXBlVHJhbnNmb3JtIHtcbiAgY29uc3RydWN0b3IocHJpdmF0ZSByZWFkb25seSB0aW1lOiBUaW1lU2VydmljZSkge31cblxuICB0cmFuc2Zvcm0oXG4gICAgcnVsZTogc3RyaW5nLFxuICAgIHN0ZXAgPSAxLFxuICAgIHtcbiAgICAgIHV0YyxcbiAgICAgIHNob3dVdGMgPSB0cnVlLFxuICAgICAgZm9ybWF0LFxuICAgICAgdHogPSB0aGlzLnRpbWUuY3VyclR6LFxuICAgICAgZm9ybWF0VHogPSB0aGlzLnRpbWUuY3VyclR6LFxuICAgICAgc2hvd0xvY2FsVHogPSB0cnVlLFxuICAgICAgcGFyc2VJbkN1cnJlbnRUeiA9IGZhbHNlLFxuICAgIH06IHtcbiAgICAgIHV0Yz86IGJvb2xlYW47XG4gICAgICBzaG93VXRjPzogYm9vbGVhbjtcbiAgICAgIGZvcm1hdD86IHN0cmluZztcbiAgICAgIHR6Pzogc3RyaW5nO1xuICAgICAgZm9ybWF0VHo/OiBzdHJpbmc7XG4gICAgICBzaG93TG9jYWxUej86IGJvb2xlYW47XG4gICAgICBwYXJzZUluQ3VycmVudFR6PzogYm9vbGVhbjtcbiAgICB9ID0ge30sXG4gICkge1xuICAgIGxldCBkYXRlU3RyaW5nID0gJ04vQSc7XG4gICAgaWYgKFxuICAgICAgIXJ1bGUgfHxcbiAgICAgICFpc0Nyb25GaWVsZENvdW50Q29ycmVjdChydWxlKSB8fFxuICAgICAgIWlzQ3JvbldlZWtEYXlDb3JyZWN0KHJ1bGUpXG4gICAgKSB7XG4gICAgICByZXR1cm4gZGF0ZVN0cmluZztcbiAgICB9XG4gICAgdHJ5IHtcbiAgICAgIC8vIOWQjuerr+ino+aekCBjcm9udGFiIOihqOi+vuW8j+S4gOWumuaYryBVVEMg5pe26Ze0XG4gICAgICAvLyBjb25zdCBpbnRlcnZhbCA9IHBhcnNlci5wYXJzZUV4cHJlc3Npb24ocnVsZSwgeyB1dGM6IGZhbHNlLCB0eiB9KTtcblxuICAgICAgLy8gdW5kZXJsb3JkIOeahOe9kee7nOajgOa1i+ebruWJjeWQjuerr+acquaMiSBVVEMg5pe26Ze06Kej5p6Q77yM5aKe5Yqg5a+55pys5Zyw5pe25Yy655qE5aSE55CGXG4gICAgICAvLyDpooTorqEgMy4xMyDljrvpmaTlr7nnvZHnu5zmo4DmtYvnmoTlhbzlrrlcbiAgICAgIC8vIFVzYWdlOiBhcHBzXFx1bmRlcmxvcmRcXHNyY1xcYXBwXFxtYW5hZ2UtcGxhdGZvcm1cXGZlYXR1cmVzXFxuZXR3b3JrLW1hbmFnZVxcdHJhY2VcbiAgICAgIGNvbnN0IGludGVydmFsID0gcGFyc2VyLnBhcnNlRXhwcmVzc2lvbihydWxlLCB7XG4gICAgICAgIHV0YzogIXBhcnNlSW5DdXJyZW50VHosXG4gICAgICAgIHR6LFxuICAgICAgfSk7XG5cbiAgICAgIGxldCB0aW1lc3RhbXA6IG51bWJlcjtcbiAgICAgIGZvciAobGV0IGkgPSAwOyBpIDwgc3RlcDsgaSsrKSB7XG4gICAgICAgIHRpbWVzdGFtcCA9IGludGVydmFsLm5leHQoKS5nZXRUaW1lKCk7XG4gICAgICB9XG4gICAgICBjb25zdCBuZXh0RGF0ZSA9IGRheWpzLnV0Yyh0aW1lc3RhbXApO1xuXG4gICAgICBjb25zdCB0ekRpc3BsYXkgPSB1dGNcbiAgICAgICAgPyBzaG93VXRjXG4gICAgICAgICAgPyBgIChVVEMpYFxuICAgICAgICAgIDogJydcbiAgICAgICAgOiBzaG93TG9jYWxUelxuICAgICAgICA/IGAgKCR7dHp9KWBcbiAgICAgICAgOiAnJztcbiAgICAgIGRhdGVTdHJpbmcgPVxuICAgICAgICB0aGlzLnRpbWUuZm9ybWF0KHV0YyA/IG5leHREYXRlIDogbmV4dERhdGUudHooZm9ybWF0VHopLCBmb3JtYXQpICtcbiAgICAgICAgdHpEaXNwbGF5O1xuICAgIH0gY2F0Y2ggKGVycikge1xuICAgICAgaWYgKGlzRGV2TW9kZSgpICYmIGlzRXJyb3JNZXNzYWdlKGVycikgJiYgIS9pbnZhbGlkL2kudGVzdChlcnIubWVzc2FnZSkpIHtcbiAgICAgICAgY29uc29sZS5lcnJvcihlcnIpO1xuICAgICAgfVxuICAgIH1cbiAgICByZXR1cm4gZGF0ZVN0cmluZztcbiAgfVxufVxuIl19

package/esm2022/core/pipes/duration.pipe.mjs

@@ -0,0 +1,51 @@
+import { Pipe } from '@angular/core';
+import dayjs from 'dayjs';
+import duration from 'dayjs/plugin/duration';
+import { TranslateService } from '../../translate/translate.service';
+import * as i0 from "@angular/core";
+import * as i1 from "../../translate/translate.service";
+dayjs.extend(duration);
+export class DurationPipe {
+    constructor(translate) {
+        this.translate = translate;
+    }
+    transform(ms) {
+        if (!ms) {
+            return '-';
+        }
+        let message = '';
+        if (ms >= 1000) {
+            const duration = dayjs.duration(ms);
+            const days = duration.days();
+            const hours = duration.hours();
+            const minutes = duration.minutes();
+            const seconds = duration.seconds();
+            message += days
+                ? days + ' ' + this.translate.get('days').toLowerCase()
+                : '';
+            message += hours
+                ? ' ' + hours + ' ' + this.translate.get('hours').toLowerCase()
+                : '';
+            message += minutes
+                ? ' ' + minutes + ' ' + this.translate.get('minutes').toLowerCase()
+                : '';
+            message += seconds
+                ? ' ' + seconds + ' ' + this.translate.get('seconds').toLowerCase()
+                : '';
+        }
+        else if (ms > 0) {
+            message = this.translate.get('less_than_a_second');
+        }
+        else {
+            message = '-';
+        }
+        return message;
+    }
+    static { this.ɵfac = function DurationPipe_Factory(t) { return new (t || DurationPipe)(i0.ɵɵdirectiveInject(i1.TranslateService, 16)); }; }
+    static { this.ɵpipe = /*@__PURE__*/ i0.ɵɵdefinePipe({ name: "aclDuration", type: DurationPipe, pure: false, standalone: true }); }
+}
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(DurationPipe, [{
+        type: Pipe,
+        args: [{ name: 'aclDuration', pure: false, standalone: true }]
+    }], function () { return [{ type: i1.TranslateService }]; }, null); })();
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/core/pipes/field-not-available.pipe.mjs

@@ -0,0 +1,25 @@
+/**
+ * @packageDocumentation
+ * @module utils
+ */
+import { Pipe } from '@angular/core';
+import * as i0 from "@angular/core";
+export const FIELD_NOT_AVAILABLE_PLACEHOLDER = '-';
+export const isFieldNotAvailable = (field) => field == null || Number.isNaN(field) || !String(field).trim();
+export class FieldNotAvailablePipe {
+    transform(field) {
+        return isFieldNotAvailable(field)
+            ? FIELD_NOT_AVAILABLE_PLACEHOLDER
+            : String(field);
+    }
+    static { this.ɵfac = function FieldNotAvailablePipe_Factory(t) { return new (t || FieldNotAvailablePipe)(); }; }
+    static { this.ɵpipe = /*@__PURE__*/ i0.ɵɵdefinePipe({ name: "aclFieldNotAvailable", type: FieldNotAvailablePipe, pure: true, standalone: true }); }
+}
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(FieldNotAvailablePipe, [{
+        type: Pipe,
+        args: [{
+                name: 'aclFieldNotAvailable',
+                standalone: true,
+            }]
+    }], null, null); })();
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZmllbGQtbm90LWF2YWlsYWJsZS5waXBlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vbGlicy9jb21tb24vc3JjL2NvcmUvcGlwZXMvZmllbGQtbm90LWF2YWlsYWJsZS5waXBlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7R0FHRztBQUVILE9BQU8sRUFBRSxJQUFJLEVBQWlCLE1BQU0sZUFBZSxDQUFDOztBQUVwRCxNQUFNLENBQUMsTUFBTSwrQkFBK0IsR0FBRyxHQUFHLENBQUM7QUFFbkQsTUFBTSxDQUFDLE1BQU0sbUJBQW1CLEdBQUcsQ0FBQyxLQUFjLEVBQVcsRUFBRSxDQUM3RCxLQUFLLElBQUksSUFBSSxJQUFJLE1BQU0sQ0FBQyxLQUFLLENBQUMsS0FBZSxDQUFDLElBQUksQ0FBQyxNQUFNLENBQUMsS0FBSyxDQUFDLENBQUMsSUFBSSxFQUFFLENBQUM7QUFNMUUsTUFBTSxPQUFPLHFCQUFxQjtJQUNoQyxTQUFTLENBQUMsS0FBYztRQUN0QixPQUFPLG1CQUFtQixDQUFDLEtBQUssQ0FBQztZQUMvQixDQUFDLENBQUMsK0JBQStCO1lBQ2pDLENBQUMsQ0FBQyxNQUFNLENBQUMsS0FBSyxDQUFDLENBQUM7SUFDcEIsQ0FBQztzRkFMVSxxQkFBcUI7OEZBQXJCLHFCQUFxQjs7dUZBQXJCLHFCQUFxQjtjQUpqQyxJQUFJO2VBQUM7Z0JBQ0osSUFBSSxFQUFFLHNCQUFzQjtnQkFDNUIsVUFBVSxFQUFFLElBQUk7YUFDakIiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIEBwYWNrYWdlRG9jdW1lbnRhdGlvblxuICogQG1vZHVsZSB1dGlsc1xuICovXG5cbmltcG9ydCB7IFBpcGUsIFBpcGVUcmFuc2Zvcm0gfSBmcm9tICdAYW5ndWxhci9jb3JlJztcblxuZXhwb3J0IGNvbnN0IEZJRUxEX05PVF9BVkFJTEFCTEVfUExBQ0VIT0xERVIgPSAnLSc7XG5cbmV4cG9ydCBjb25zdCBpc0ZpZWxkTm90QXZhaWxhYmxlID0gKGZpZWxkOiB1bmtub3duKTogYm9vbGVhbiA9PlxuICBmaWVsZCA9PSBudWxsIHx8IE51bWJlci5pc05hTihmaWVsZCBhcyBudW1iZXIpIHx8ICFTdHJpbmcoZmllbGQpLnRyaW0oKTtcblxuQFBpcGUoe1xuICBuYW1lOiAnYWNsRmllbGROb3RBdmFpbGFibGUnLFxuICBzdGFuZGFsb25lOiB0cnVlLFxufSlcbmV4cG9ydCBjbGFzcyBGaWVsZE5vdEF2YWlsYWJsZVBpcGUgaW1wbGVtZW50cyBQaXBlVHJhbnNmb3JtIHtcbiAgdHJhbnNmb3JtKGZpZWxkOiB1bmtub3duKSB7XG4gICAgcmV0dXJuIGlzRmllbGROb3RBdmFpbGFibGUoZmllbGQpXG4gICAgICA/IEZJRUxEX05PVF9BVkFJTEFCTEVfUExBQ0VIT0xERVJcbiAgICAgIDogU3RyaW5nKGZpZWxkKTtcbiAgfVxufVxuIl19

package/esm2022/core/pipes/img-header.pipe.mjs

@@ -0,0 +1,18 @@
+import { Pipe } from '@angular/core';
+import { appendImageHeader } from '../public-api';
+import * as i0 from "@angular/core";
+export class ImgHeaderPipe {
+    transform(value, prefix) {
+        return appendImageHeader(value, prefix);
+    }
+    static { this.ɵfac = function ImgHeaderPipe_Factory(t) { return new (t || ImgHeaderPipe)(); }; }
+    static { this.ɵpipe = /*@__PURE__*/ i0.ɵɵdefinePipe({ name: "aclImageHeader", type: ImgHeaderPipe, pure: true, standalone: true }); }
+}
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(ImgHeaderPipe, [{
+        type: Pipe,
+        args: [{
+                name: 'aclImageHeader',
+                standalone: true,
+            }]
+    }], null, null); })();
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW1nLWhlYWRlci5waXBlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vbGlicy9jb21tb24vc3JjL2NvcmUvcGlwZXMvaW1nLWhlYWRlci5waXBlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxJQUFJLEVBQWlCLE1BQU0sZUFBZSxDQUFDO0FBRXBELE9BQU8sRUFBRSxpQkFBaUIsRUFBRSxNQUFNLGVBQWUsQ0FBQzs7QUFNbEQsTUFBTSxPQUFPLGFBQWE7SUFDeEIsU0FBUyxDQUFDLEtBQWEsRUFBRSxNQUFlO1FBQ3RDLE9BQU8saUJBQWlCLENBQUMsS0FBSyxFQUFFLE1BQU0sQ0FBQyxDQUFDO0lBQzFDLENBQUM7OEVBSFUsYUFBYTt3RkFBYixhQUFhOzt1RkFBYixhQUFhO2NBSnpCLElBQUk7ZUFBQztnQkFDSixJQUFJLEVBQUUsZ0JBQWdCO2dCQUN0QixVQUFVLEVBQUUsSUFBSTthQUNqQiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IFBpcGUsIFBpcGVUcmFuc2Zvcm0gfSBmcm9tICdAYW5ndWxhci9jb3JlJztcblxuaW1wb3J0IHsgYXBwZW5kSW1hZ2VIZWFkZXIgfSBmcm9tICcuLi9wdWJsaWMtYXBpJztcblxuQFBpcGUoe1xuICBuYW1lOiAnYWNsSW1hZ2VIZWFkZXInLFxuICBzdGFuZGFsb25lOiB0cnVlLFxufSlcbmV4cG9ydCBjbGFzcyBJbWdIZWFkZXJQaXBlIGltcGxlbWVudHMgUGlwZVRyYW5zZm9ybSB7XG4gIHRyYW5zZm9ybSh2YWx1ZTogc3RyaW5nLCBwcmVmaXg/OiBzdHJpbmcpIHtcbiAgICByZXR1cm4gYXBwZW5kSW1hZ2VIZWFkZXIodmFsdWUsIHByZWZpeCk7XG4gIH1cbn1cbiJdfQ==