@alauda-fe/common 1.0.0-next.0

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/index.mjs

@@ -0,0 +1,2 @@
+export * from './public-api';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9saWJzL2NvbW1vbi9zcmMvY29yZS9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLGNBQWMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vcHVibGljLWFwaSc7XG4iXX0=

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/module';
+import { PurePipeModule } from '../scm';
+import { ClickOutsideDirective, InterceptDeactivateDirective, ScrollBorderObserverDirective, ScrollToFirstInvalidDirective, ScrollToFirstInvalidMarkerDirective, } from './directives';
+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 { ReadonlyFieldDirective, SpanComponent, } from './directives/readonly-field.directive';
+import { ResizeDirective } from './directives/resize.directive';
+import { CronHumanReadablePipe, LocaleTransformPipe, MarkedPipe, RelativeTimePipe, StandardDatePipe, StandardTimePipe, ThemeTransformPipe, TimezoneDisplayPipe, TrustUrlPipe, } from './pipes';
+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 { SafePipe } from './pipes/safe.pipe';
+import * as i0 from "@angular/core";
+const STANDS = [
+    ReadonlyFieldDirective,
+    PurePipeModule,
+    ParseJsonTranslatePipe,
+    FieldNotAvailablePipe,
+    ImgHeaderPipe,
+    SafePipe,
+    RelativeTimePipe,
+    PageHeaderContentDirective,
+    StandardTimePipe,
+    ScrollToFirstInvalidDirective,
+    InterceptDeactivateDirective,
+    DisabledDirective,
+    ClickOutsideDirective,
+    ScrollBorderObserverDirective,
+    ResizeDirective,
+];
+const PIPES = [
+    // time pipes
+    StandardDatePipe,
+    TrustUrlPipe,
+    CrontabNextPipe,
+    ImgThemePipe,
+    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,
+        TrustUrlPipe,
+        CrontabNextPipe,
+        ImgThemePipe,
+        MarkedPipe,
+        LocaleTransformPipe,
+        ThemeTransformPipe,
+        TimezoneDisplayPipe,
+        CronHumanReadablePipe, FeatureGateDirective,
+        ScrollToFirstInvalidMarkerDirective,
+        FormItemMarginEffectDirective, SpanComponent], imports: [CommonModule,
+        ReactiveFormsModule, ReadonlyFieldDirective,
+        PurePipeModule,
+        ParseJsonTranslatePipe,
+        FieldNotAvailablePipe,
+        ImgHeaderPipe,
+        SafePipe,
+        RelativeTimePipe,
+        PageHeaderContentDirective,
+        StandardTimePipe,
+        ScrollToFirstInvalidDirective,
+        InterceptDeactivateDirective,
+        DisabledDirective,
+        ClickOutsideDirective,
+        ScrollBorderObserverDirective,
+        ResizeDirective, K8sUtilPipeModule,
+        EffectDirectiveModule], exports: [
+        // time pipes
+        StandardDatePipe,
+        TrustUrlPipe,
+        CrontabNextPipe,
+        ImgThemePipe,
+        MarkedPipe,
+        LocaleTransformPipe,
+        ThemeTransformPipe,
+        TimezoneDisplayPipe,
+        CronHumanReadablePipe, FeatureGateDirective,
+        ScrollToFirstInvalidMarkerDirective,
+        FormItemMarginEffectDirective, ReadonlyFieldDirective,
+        PurePipeModule,
+        ParseJsonTranslatePipe,
+        FieldNotAvailablePipe,
+        ImgHeaderPipe,
+        SafePipe,
+        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,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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 '..';
+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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW1nLWhlYWRlci5waXBlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vbGlicy9jb21tb24vc3JjL2NvcmUvcGlwZXMvaW1nLWhlYWRlci5waXBlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxJQUFJLEVBQWlCLE1BQU0sZUFBZSxDQUFDO0FBRXBELE9BQU8sRUFBRSxpQkFBaUIsRUFBRSxNQUFNLElBQUksQ0FBQzs7QUFNdkMsTUFBTSxPQUFPLGFBQWE7SUFDeEIsU0FBUyxDQUFDLEtBQWEsRUFBRSxNQUFlO1FBQ3RDLE9BQU8saUJBQWlCLENBQUMsS0FBSyxFQUFFLE1BQU0sQ0FBQyxDQUFDO0lBQzFDLENBQUM7OEVBSFUsYUFBYTt3RkFBYixhQUFhOzt1RkFBYixhQUFhO2NBSnpCLElBQUk7ZUFBQztnQkFDSixJQUFJLEVBQUUsZ0JBQWdCO2dCQUN0QixVQUFVLEVBQUUsSUFBSTthQUNqQiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IFBpcGUsIFBpcGVUcmFuc2Zvcm0gfSBmcm9tICdAYW5ndWxhci9jb3JlJztcblxuaW1wb3J0IHsgYXBwZW5kSW1hZ2VIZWFkZXIgfSBmcm9tICcuLic7XG5cbkBQaXBlKHtcbiAgbmFtZTogJ2FjbEltYWdlSGVhZGVyJyxcbiAgc3RhbmRhbG9uZTogdHJ1ZSxcbn0pXG5leHBvcnQgY2xhc3MgSW1nSGVhZGVyUGlwZSBpbXBsZW1lbnRzIFBpcGVUcmFuc2Zvcm0ge1xuICB0cmFuc2Zvcm0odmFsdWU6IHN0cmluZywgcHJlZml4Pzogc3RyaW5nKSB7XG4gICAgcmV0dXJuIGFwcGVuZEltYWdlSGVhZGVyKHZhbHVlLCBwcmVmaXgpO1xuICB9XG59XG4iXX0=

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

@@ -0,0 +1,37 @@
+import { ThemeService } from '@alauda/ui';
+import { ChangeDetectorRef, Pipe, } from '@angular/core';
+import { Subject, takeUntil } from 'rxjs';
+import * as i0 from "@angular/core";
+import * as i1 from "@alauda/ui";
+/*
+  因为业务中有很多图片需要在浅色和暗色两个主题切换后使用不同的图片。
+  推荐在业务中建两个图片的文件夹，light 和 dark，把两种主题对应的图片放在这两个目录下
+  <img src="icons/xxx/xxx.svg" > 变更为 <img [src]="'icons/$theme/xxx/xxx.svg' | aclImageTheme" >
+*/
+export class ImgThemePipe {
+    constructor(theme, cdr) {
+        this.theme = theme;
+        this.cdr = cdr;
+        this.destroy$$ = new Subject();
+        this.theme.currentTheme$.pipe(takeUntil(this.destroy$$)).subscribe(() => {
+            this.cdr.markForCheck();
+        });
+    }
+    transform(value) {
+        return value.replace('$theme', this.theme.currentTheme());
+    }
+    ngOnDestroy() {
+        this.destroy$$.next();
+        this.destroy$$.complete();
+    }
+    static { this.ɵfac = function ImgThemePipe_Factory(t) { return new (t || ImgThemePipe)(i0.ɵɵdirectiveInject(i1.ThemeService, 16), i0.ɵɵdirectiveInject(i0.ChangeDetectorRef, 16)); }; }
+    static { this.ɵpipe = /*@__PURE__*/ i0.ɵɵdefinePipe({ name: "aclImageTheme", type: ImgThemePipe, pure: false }); }
+}
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(ImgThemePipe, [{
+        type: Pipe,
+        args: [{
+                name: 'aclImageTheme',
+                pure: false,
+            }]
+    }], function () { return [{ type: i1.ThemeService }, { type: i0.ChangeDetectorRef }]; }, null); })();
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/core/pipes/index.mjs

@@ -0,0 +1,18 @@
+export * from './crontab-next.pipe';
+export * from './field-not-available.pipe';
+export * from './img-header.pipe';
+export * from './img-theme.pipe';
+export * from './k8s-util.pipe';
+export * from './keyvalue.pipe';
+export * from './safe.pipe';
+export * from './time.pipe';
+export * from './trust-url.pipe';
+export * from './page-env.pipe';
+export * from './marked.pipe';
+export * from './parse-json-translate.pipe';
+export * from './timezone-display.pipe';
+export * from './cron-human-readable.pipe';
+export * from './k8s-util.pipe.module';
+export { ParseJsonPipe } from './parse-json.pipe';
+export { MinimumFormatPipe } from './minimum-format.pipe';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9saWJzL2NvbW1vbi9zcmMvY29yZS9waXBlcy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLHFCQUFxQixDQUFDO0FBQ3BDLGNBQWMsNEJBQTRCLENBQUM7QUFDM0MsY0FBYyxtQkFBbUIsQ0FBQztBQUNsQyxjQUFjLGtCQUFrQixDQUFDO0FBQ2pDLGNBQWMsaUJBQWlCLENBQUM7QUFDaEMsY0FBYyxpQkFBaUIsQ0FBQztBQUNoQyxjQUFjLGFBQWEsQ0FBQztBQUM1QixjQUFjLGFBQWEsQ0FBQztBQUM1QixjQUFjLGtCQUFrQixDQUFDO0FBQ2pDLGNBQWMsaUJBQWlCLENBQUM7QUFDaEMsY0FBYyxlQUFlLENBQUM7QUFDOUIsY0FBYyw2QkFBNkIsQ0FBQztBQUM1QyxjQUFjLHlCQUF5QixDQUFDO0FBQ3hDLGNBQWMsNEJBQTRCLENBQUM7QUFDM0MsY0FBYyx3QkFBd0IsQ0FBQztBQUN2QyxPQUFPLEVBQUUsYUFBYSxFQUFFLE1BQU0sbUJBQW1CLENBQUM7QUFDbEQsT0FBTyxFQUFFLGlCQUFpQixFQUFFLE1BQU0sdUJBQXVCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL2Nyb250YWItbmV4dC5waXBlJztcbmV4cG9ydCAqIGZyb20gJy4vZmllbGQtbm90LWF2YWlsYWJsZS5waXBlJztcbmV4cG9ydCAqIGZyb20gJy4vaW1nLWhlYWRlci5waXBlJztcbmV4cG9ydCAqIGZyb20gJy4vaW1nLXRoZW1lLnBpcGUnO1xuZXhwb3J0ICogZnJvbSAnLi9rOHMtdXRpbC5waXBlJztcbmV4cG9ydCAqIGZyb20gJy4va2V5dmFsdWUucGlwZSc7XG5leHBvcnQgKiBmcm9tICcuL3NhZmUucGlwZSc7XG5leHBvcnQgKiBmcm9tICcuL3RpbWUucGlwZSc7XG5leHBvcnQgKiBmcm9tICcuL3RydXN0LXVybC5waXBlJztcbmV4cG9ydCAqIGZyb20gJy4vcGFnZS1lbnYucGlwZSc7XG5leHBvcnQgKiBmcm9tICcuL21hcmtlZC5waXBlJztcbmV4cG9ydCAqIGZyb20gJy4vcGFyc2UtanNvbi10cmFuc2xhdGUucGlwZSc7XG5leHBvcnQgKiBmcm9tICcuL3RpbWV6b25lLWRpc3BsYXkucGlwZSc7XG5leHBvcnQgKiBmcm9tICcuL2Nyb24taHVtYW4tcmVhZGFibGUucGlwZSc7XG5leHBvcnQgKiBmcm9tICcuL2s4cy11dGlsLnBpcGUubW9kdWxlJztcbmV4cG9ydCB7IFBhcnNlSnNvblBpcGUgfSBmcm9tICcuL3BhcnNlLWpzb24ucGlwZSc7XG5leHBvcnQgeyBNaW5pbXVtRm9ybWF0UGlwZSB9IGZyb20gJy4vbWluaW11bS1mb3JtYXQucGlwZSc7XG4iXX0=