@alauda-fe/common 1.0.0-next.0

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

@@ -0,0 +1,115 @@
+/**
+ * @packageDocumentation
+ * @module utils
+ */
+import { ChangeDetectorRef, Injectable, Pipe, } from '@angular/core';
+import dayjs from 'dayjs';
+import { Subject, takeUntil } from 'rxjs';
+import { TranslateService } from '../../translate/translate.service';
+import { DATE_FORMAT, DATE_TIME_FORMAT } from '../constants';
+import { TimeService } from '../services';
+import { FIELD_NOT_AVAILABLE_PLACEHOLDER } from './field-not-available.pipe';
+import * as i0 from "@angular/core";
+import * as i1 from "../services";
+import * as i2 from "../../translate/translate.service";
+const MILLISECONDS_SECOND = 1000;
+const MILLISECONDS_MINUTE = MILLISECONDS_SECOND * 60;
+const MILLISECONDS_HOUR = MILLISECONDS_MINUTE * 60;
+const MILLISECONDS_DAY = MILLISECONDS_HOUR * 24;
+const MILLISECONDS_WEEK = MILLISECONDS_DAY * 7;
+export class RelativeTimePipe {
+    constructor(cdr, time, translate) {
+        this.cdr = cdr;
+        this.time = time;
+        this.translate = translate;
+        this.destroy$$ = new Subject();
+        this.translate.locale$
+            .pipe(takeUntil(this.destroy$$))
+            .subscribe(() => this.cdr.markForCheck());
+    }
+    ngOnDestroy() {
+        this.destroy$$.next();
+        this.destroy$$.complete();
+        if (this.timerId) {
+            clearTimeout(this.timerId);
+        }
+    }
+    transform(value) {
+        if (!value?.toString().trim()) {
+            return FIELD_NOT_AVAILABLE_PLACEHOLDER;
+        }
+        const currentTime = Date.now();
+        const givenTime = dayjs(value).valueOf();
+        const distance = currentTime - givenTime;
+        if (distance >= MILLISECONDS_WEEK) {
+            return this.time.format(value, DATE_FORMAT);
+        }
+        this.checkDistance(distance);
+        return distance < MILLISECONDS_MINUTE
+            ? this.translate.get('just_now')
+            : this.time.distance(givenTime, currentTime);
+    }
+    checkDistance(distance) {
+        if (distance < MILLISECONDS_MINUTE) {
+            return this.startTimer(MILLISECONDS_SECOND);
+        }
+        if (distance < MILLISECONDS_HOUR) {
+            return this.startTimer(MILLISECONDS_MINUTE);
+        }
+        if (distance < MILLISECONDS_DAY) {
+            return this.startTimer(MILLISECONDS_HOUR);
+        }
+        return this.startTimer(MILLISECONDS_DAY);
+    }
+    startTimer(timeout) {
+        clearTimeout(this.timerId);
+        this.timerId = window.setTimeout(() => this.cdr.markForCheck(), timeout);
+    }
+    static { this.ɵfac = function RelativeTimePipe_Factory(t) { return new (t || RelativeTimePipe)(i0.ɵɵdirectiveInject(i0.ChangeDetectorRef, 16), i0.ɵɵdirectiveInject(i1.TimeService, 16), i0.ɵɵdirectiveInject(i2.TranslateService, 16)); }; }
+    static { this.ɵpipe = /*@__PURE__*/ i0.ɵɵdefinePipe({ name: "aclRelativeTime", type: RelativeTimePipe, pure: false, standalone: true }); }
+}
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(RelativeTimePipe, [{
+        type: Pipe,
+        args: [{ name: 'aclRelativeTime', pure: false, standalone: true }]
+    }], function () { return [{ type: i0.ChangeDetectorRef }, { type: i1.TimeService }, { type: i2.TranslateService }]; }, null); })();
+export class DateTimePipe {
+    constructor(time) {
+        this.time = time;
+    }
+    transform(value, utc = false) {
+        if (!value?.toString().trim()) {
+            return FIELD_NOT_AVAILABLE_PLACEHOLDER;
+        }
+        return this.time.format(utc ? dayjs.utc(value) : value, this.format);
+    }
+    static { this.ɵfac = function DateTimePipe_Factory(t) { return new (t || DateTimePipe)(i0.ɵɵinject(i1.TimeService)); }; }
+    static { this.ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: DateTimePipe, factory: DateTimePipe.ɵfac }); }
+}
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(DateTimePipe, [{
+        type: Injectable
+    }], function () { return [{ type: i1.TimeService }]; }, null); })();
+export class StandardTimePipe extends DateTimePipe {
+    constructor() {
+        super(...arguments);
+        this.format = DATE_TIME_FORMAT;
+    }
+    static { this.ɵfac = /*@__PURE__*/ function () { let ɵStandardTimePipe_BaseFactory; return function StandardTimePipe_Factory(t) { return (ɵStandardTimePipe_BaseFactory || (ɵStandardTimePipe_BaseFactory = i0.ɵɵgetInheritedFactory(StandardTimePipe)))(t || StandardTimePipe); }; }(); }
+    static { this.ɵpipe = /*@__PURE__*/ i0.ɵɵdefinePipe({ name: "aclStandardTime", type: StandardTimePipe, pure: true, standalone: true }); }
+}
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(StandardTimePipe, [{
+        type: Pipe,
+        args: [{ name: 'aclStandardTime', standalone: true }]
+    }], null, null); })();
+export class StandardDatePipe extends DateTimePipe {
+    constructor() {
+        super(...arguments);
+        this.format = DATE_FORMAT;
+    }
+    static { this.ɵfac = /*@__PURE__*/ function () { let ɵStandardDatePipe_BaseFactory; return function StandardDatePipe_Factory(t) { return (ɵStandardDatePipe_BaseFactory || (ɵStandardDatePipe_BaseFactory = i0.ɵɵgetInheritedFactory(StandardDatePipe)))(t || StandardDatePipe); }; }(); }
+    static { this.ɵpipe = /*@__PURE__*/ i0.ɵɵdefinePipe({ name: "aclStandardDate", type: StandardDatePipe, pure: true }); }
+}
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(StandardDatePipe, [{
+        type: Pipe,
+        args: [{ name: 'aclStandardDate' }]
+    }], null, null); })();
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"time.pipe.js","sourceRoot":"","sources":["../../../../../../libs/common/src/core/pipes/time.pipe.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @packageDocumentation\n * @module utils\n */\n\nimport {\n  ChangeDetectorRef,\n  Injectable,\n  OnDestroy,\n  Pipe,\n  PipeTransform,\n} from '@angular/core';\nimport dayjs, { ConfigType } from 'dayjs';\nimport { Subject, takeUntil } from 'rxjs';\n\nimport { TranslateService } from '../../translate/translate.service';\nimport { DATE_FORMAT, DATE_TIME_FORMAT } from '../constants';\nimport { TimeService } from '../services';\n\nimport { FIELD_NOT_AVAILABLE_PLACEHOLDER } from './field-not-available.pipe';\n\nconst MILLISECONDS_SECOND = 1000;\nconst MILLISECONDS_MINUTE = MILLISECONDS_SECOND * 60;\nconst MILLISECONDS_HOUR = MILLISECONDS_MINUTE * 60;\nconst MILLISECONDS_DAY = MILLISECONDS_HOUR * 24;\nconst MILLISECONDS_WEEK = MILLISECONDS_DAY * 7;\n\n@Pipe({ name: 'aclRelativeTime', pure: false, standalone: true })\nexport class RelativeTimePipe implements PipeTransform, OnDestroy {\n  private readonly destroy$$ = new Subject<void>();\n\n  private timerId: number;\n\n  constructor(\n    private readonly cdr: ChangeDetectorRef,\n    private readonly time: TimeService,\n    private readonly translate: TranslateService,\n  ) {\n    this.translate.locale$\n      .pipe(takeUntil(this.destroy$$))\n      .subscribe(() => this.cdr.markForCheck());\n  }\n\n  ngOnDestroy() {\n    this.destroy$$.next();\n    this.destroy$$.complete();\n\n    if (this.timerId) {\n      clearTimeout(this.timerId);\n    }\n  }\n\n  transform(value: ConfigType) {\n    if (!value?.toString().trim()) {\n      return FIELD_NOT_AVAILABLE_PLACEHOLDER;\n    }\n\n    const currentTime = Date.now();\n    const givenTime = dayjs(value).valueOf();\n\n    const distance = currentTime - givenTime;\n\n    if (distance >= MILLISECONDS_WEEK) {\n      return this.time.format(value, DATE_FORMAT);\n    }\n\n    this.checkDistance(distance);\n\n    return distance < MILLISECONDS_MINUTE\n      ? this.translate.get('just_now')\n      : this.time.distance(givenTime, currentTime);\n  }\n\n  protected checkDistance(distance: number) {\n    if (distance < MILLISECONDS_MINUTE) {\n      return this.startTimer(MILLISECONDS_SECOND);\n    }\n\n    if (distance < MILLISECONDS_HOUR) {\n      return this.startTimer(MILLISECONDS_MINUTE);\n    }\n\n    if (distance < MILLISECONDS_DAY) {\n      return this.startTimer(MILLISECONDS_HOUR);\n    }\n\n    return this.startTimer(MILLISECONDS_DAY);\n  }\n\n  private startTimer(timeout: number) {\n    clearTimeout(this.timerId);\n    this.timerId = window.setTimeout(() => this.cdr.markForCheck(), timeout);\n  }\n}\n\n@Injectable()\nexport abstract class DateTimePipe implements PipeTransform {\n  abstract format: string;\n\n  constructor(private readonly time: TimeService) {}\n\n  transform(value: ConfigType, utc = false) {\n    if (!value?.toString().trim()) {\n      return FIELD_NOT_AVAILABLE_PLACEHOLDER;\n    }\n\n    return this.time.format(utc ? dayjs.utc(value) : value, this.format);\n  }\n}\n\n@Pipe({ name: 'aclStandardTime', standalone: true })\nexport class StandardTimePipe extends DateTimePipe implements PipeTransform {\n  override format = DATE_TIME_FORMAT;\n}\n\n@Pipe({ name: 'aclStandardDate' })\nexport class StandardDatePipe extends DateTimePipe implements PipeTransform {\n  override format = DATE_FORMAT;\n}\n"]}

package/esm2022/core/pipes/timezone-display.pipe.mjs

@@ -0,0 +1,21 @@
+import { Pipe } from '@angular/core';
+import { TIMEZONES } from '../constants/timezones';
+import * as i0 from "@angular/core";
+export class TimezoneDisplayPipe {
+    transform(tz) {
+        const matched = TIMEZONES.find(t => t.tzCode === tz);
+        return {
+            zh: matched.name_zh,
+            en: matched.name,
+        };
+    }
+    static { this.ɵfac = function TimezoneDisplayPipe_Factory(t) { return new (t || TimezoneDisplayPipe)(); }; }
+    static { this.ɵpipe = /*@__PURE__*/ i0.ɵɵdefinePipe({ name: "aclTimezoneDisplay", type: TimezoneDisplayPipe, pure: true }); }
+}
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(TimezoneDisplayPipe, [{
+        type: Pipe,
+        args: [{
+                name: 'aclTimezoneDisplay',
+            }]
+    }], null, null); })();
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidGltZXpvbmUtZGlzcGxheS5waXBlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vbGlicy9jb21tb24vc3JjL2NvcmUvcGlwZXMvdGltZXpvbmUtZGlzcGxheS5waXBlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxJQUFJLEVBQWlCLE1BQU0sZUFBZSxDQUFDO0FBRXBELE9BQU8sRUFBRSxTQUFTLEVBQUUsTUFBTSx3QkFBd0IsQ0FBQzs7QUFLbkQsTUFBTSxPQUFPLG1CQUFtQjtJQUM5QixTQUFTLENBQUMsRUFBVTtRQUNsQixNQUFNLE9BQU8sR0FBRyxTQUFTLENBQUMsSUFBSSxDQUFDLENBQUMsQ0FBQyxFQUFFLENBQUMsQ0FBQyxDQUFDLE1BQU0sS0FBSyxFQUFFLENBQUMsQ0FBQztRQUNyRCxPQUFPO1lBQ0wsRUFBRSxFQUFFLE9BQU8sQ0FBQyxPQUFPO1lBQ25CLEVBQUUsRUFBRSxPQUFPLENBQUMsSUFBSTtTQUNqQixDQUFDO0lBQ0osQ0FBQztvRkFQVSxtQkFBbUI7NEZBQW5CLG1CQUFtQjs7dUZBQW5CLG1CQUFtQjtjQUgvQixJQUFJO2VBQUM7Z0JBQ0osSUFBSSxFQUFFLG9CQUFvQjthQUMzQiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IFBpcGUsIFBpcGVUcmFuc2Zvcm0gfSBmcm9tICdAYW5ndWxhci9jb3JlJztcblxuaW1wb3J0IHsgVElNRVpPTkVTIH0gZnJvbSAnLi4vY29uc3RhbnRzL3RpbWV6b25lcyc7XG5cbkBQaXBlKHtcbiAgbmFtZTogJ2FjbFRpbWV6b25lRGlzcGxheScsXG59KVxuZXhwb3J0IGNsYXNzIFRpbWV6b25lRGlzcGxheVBpcGUgaW1wbGVtZW50cyBQaXBlVHJhbnNmb3JtIHtcbiAgdHJhbnNmb3JtKHR6OiBzdHJpbmcpIHtcbiAgICBjb25zdCBtYXRjaGVkID0gVElNRVpPTkVTLmZpbmQodCA9PiB0LnR6Q29kZSA9PT0gdHopO1xuICAgIHJldHVybiB7XG4gICAgICB6aDogbWF0Y2hlZC5uYW1lX3poLFxuICAgICAgZW46IG1hdGNoZWQubmFtZSxcbiAgICB9O1xuICB9XG59XG4iXX0=

package/esm2022/core/pipes/trust-url.pipe.mjs

@@ -0,0 +1,28 @@
+import { Pipe } from '@angular/core';
+import { DomSanitizer } from '@angular/platform-browser';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/platform-browser";
+/**
+ * Pipe a URL string to safe state.
+ *
+ * Angular has some native security concerns on how to interpolate html content,
+ * we shall bypass it with some magic.
+ *
+ * Credit:
+ * - http://stackoverflow.com/questions/39628007/angular2-innerhtml-binding-remove-style-attribute
+ */
+export class TrustUrlPipe {
+    constructor(sanitizer) {
+        this.sanitizer = sanitizer;
+    }
+    transform(url) {
+        return url ? this.sanitizer.bypassSecurityTrustUrl(url) : undefined;
+    }
+    static { this.ɵfac = function TrustUrlPipe_Factory(t) { return new (t || TrustUrlPipe)(i0.ɵɵdirectiveInject(i1.DomSanitizer, 16)); }; }
+    static { this.ɵpipe = /*@__PURE__*/ i0.ɵɵdefinePipe({ name: "aclTrustUrl", type: TrustUrlPipe, pure: true }); }
+}
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(TrustUrlPipe, [{
+        type: Pipe,
+        args: [{ name: 'aclTrustUrl' }]
+    }], function () { return [{ type: i1.DomSanitizer }]; }, null); })();
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHJ1c3QtdXJsLnBpcGUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9saWJzL2NvbW1vbi9zcmMvY29yZS9waXBlcy90cnVzdC11cmwucGlwZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsSUFBSSxFQUFpQixNQUFNLGVBQWUsQ0FBQztBQUNwRCxPQUFPLEVBQUUsWUFBWSxFQUFZLE1BQU0sMkJBQTJCLENBQUM7OztBQUVuRTs7Ozs7Ozs7R0FRRztBQUVILE1BQU0sT0FBTyxZQUFZO0lBQ3ZCLFlBQTZCLFNBQXVCO1FBQXZCLGNBQVMsR0FBVCxTQUFTLENBQWM7SUFBRyxDQUFDO0lBRXhELFNBQVMsQ0FBQyxHQUFXO1FBQ25CLE9BQU8sR0FBRyxDQUFDLENBQUMsQ0FBQyxJQUFJLENBQUMsU0FBUyxDQUFDLHNCQUFzQixDQUFDLEdBQUcsQ0FBQyxDQUFDLENBQUMsQ0FBQyxTQUFTLENBQUM7SUFDdEUsQ0FBQzs2RUFMVSxZQUFZO3FGQUFaLFlBQVk7O3VGQUFaLFlBQVk7Y0FEeEIsSUFBSTtlQUFDLEVBQUUsSUFBSSxFQUFFLGFBQWEsRUFBRSIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IFBpcGUsIFBpcGVUcmFuc2Zvcm0gfSBmcm9tICdAYW5ndWxhci9jb3JlJztcbmltcG9ydCB7IERvbVNhbml0aXplciwgU2FmZUh0bWwgfSBmcm9tICdAYW5ndWxhci9wbGF0Zm9ybS1icm93c2VyJztcblxuLyoqXG4gKiBQaXBlIGEgVVJMIHN0cmluZyB0byBzYWZlIHN0YXRlLlxuICpcbiAqIEFuZ3VsYXIgaGFzIHNvbWUgbmF0aXZlIHNlY3VyaXR5IGNvbmNlcm5zIG9uIGhvdyB0byBpbnRlcnBvbGF0ZSBodG1sIGNvbnRlbnQsXG4gKiB3ZSBzaGFsbCBieXBhc3MgaXQgd2l0aCBzb21lIG1hZ2ljLlxuICpcbiAqIENyZWRpdDpcbiAqIC0gaHR0cDovL3N0YWNrb3ZlcmZsb3cuY29tL3F1ZXN0aW9ucy8zOTYyODAwNy9hbmd1bGFyMi1pbm5lcmh0bWwtYmluZGluZy1yZW1vdmUtc3R5bGUtYXR0cmlidXRlXG4gKi9cbkBQaXBlKHsgbmFtZTogJ2FjbFRydXN0VXJsJyB9KVxuZXhwb3J0IGNsYXNzIFRydXN0VXJsUGlwZSBpbXBsZW1lbnRzIFBpcGVUcmFuc2Zvcm0ge1xuICBjb25zdHJ1Y3Rvcihwcml2YXRlIHJlYWRvbmx5IHNhbml0aXplcjogRG9tU2FuaXRpemVyKSB7fVxuXG4gIHRyYW5zZm9ybSh1cmw6IHN0cmluZyk6IFNhZmVIdG1sIHtcbiAgICByZXR1cm4gdXJsID8gdGhpcy5zYW5pdGl6ZXIuYnlwYXNzU2VjdXJpdHlUcnVzdFVybCh1cmwpIDogdW5kZWZpbmVkO1xuICB9XG59XG4iXX0=

package/esm2022/core/public-api.mjs

@@ -0,0 +1,17 @@
+/**
+ * [[include:utils/README.md]]
+ * @module utils
+ * @preferred
+ */
+/** imports */
+export * from './constants';
+export * from './abstract';
+export * from './directives';
+export * from './guards';
+export * from './pipes';
+export * from './services';
+export * from './utils';
+export * from './module';
+export * from './types';
+export * from './components';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL2xpYnMvY29tbW9uL3NyYy9jb3JlL3B1YmxpYy1hcGkudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7Ozs7R0FJRztBQUVILGNBQWM7QUFDZCxjQUFjLGFBQWEsQ0FBQztBQUM1QixjQUFjLFlBQVksQ0FBQztBQUMzQixjQUFjLGNBQWMsQ0FBQztBQUM3QixjQUFjLFVBQVUsQ0FBQztBQUN6QixjQUFjLFNBQVMsQ0FBQztBQUN4QixjQUFjLFlBQVksQ0FBQztBQUMzQixjQUFjLFNBQVMsQ0FBQztBQUN4QixjQUFjLFVBQVUsQ0FBQztBQUN6QixjQUFjLFNBQVMsQ0FBQztBQUN4QixjQUFjLGNBQWMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogW1tpbmNsdWRlOnV0aWxzL1JFQURNRS5tZF1dXG4gKiBAbW9kdWxlIHV0aWxzXG4gKiBAcHJlZmVycmVkXG4gKi9cblxuLyoqIGltcG9ydHMgKi9cbmV4cG9ydCAqIGZyb20gJy4vY29uc3RhbnRzJztcbmV4cG9ydCAqIGZyb20gJy4vYWJzdHJhY3QnO1xuZXhwb3J0ICogZnJvbSAnLi9kaXJlY3RpdmVzJztcbmV4cG9ydCAqIGZyb20gJy4vZ3VhcmRzJztcbmV4cG9ydCAqIGZyb20gJy4vcGlwZXMnO1xuZXhwb3J0ICogZnJvbSAnLi9zZXJ2aWNlcyc7XG5leHBvcnQgKiBmcm9tICcuL3V0aWxzJztcbmV4cG9ydCAqIGZyb20gJy4vbW9kdWxlJztcbmV4cG9ydCAqIGZyb20gJy4vdHlwZXMnO1xuZXhwb3J0ICogZnJvbSAnLi9jb21wb25lbnRzJztcbiJdfQ==

package/esm2022/core/services/aui-paginator-intl.service.mjs

@@ -0,0 +1,26 @@
+import { Injectable } from '@angular/core';
+import { TranslateService } from '../../translate/translate.service';
+import * as i0 from "@angular/core";
+import * as i1 from "../../translate/translate.service";
+export class AuiPaginatorIntl {
+    get itemsPerPageLabel() {
+        return this.translate.get('paginator_page_items');
+    }
+    get jumperLabelPrefix() {
+        return this.translate.get('pagination_goto');
+    }
+    get jumperLabelSuffix() {
+        return this.translate.get('pagination_page');
+    }
+    constructor(translate) {
+        this.translate = translate;
+        this.changes = this.translate.locale$;
+        this.getTotalLabel = (length) => this.translate.get('paginator_total_records', { length });
+    }
+    static { this.ɵfac = function AuiPaginatorIntl_Factory(t) { return new (t || AuiPaginatorIntl)(i0.ɵɵinject(i1.TranslateService)); }; }
+    static { this.ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: AuiPaginatorIntl, factory: AuiPaginatorIntl.ɵfac }); }
+}
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(AuiPaginatorIntl, [{
+        type: Injectable
+    }], function () { return [{ type: i1.TranslateService }]; }, null); })();
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/core/services/aui-tooltip-copy-intl.service.mjs

@@ -0,0 +1,24 @@
+import { Injectable } from '@angular/core';
+import { TranslateService } from '../../translate/translate.service';
+import * as i0 from "@angular/core";
+import * as i1 from "../../translate/translate.service";
+export class AuiTooltipCopyIntl {
+    constructor(translate) {
+        this.translate = translate;
+    }
+    get copyTip() {
+        return this.translate.get('tooltip_copy_click_to_copy');
+    }
+    get copySuccessTip() {
+        return this.translate.get('tooltip_copy_succeeded');
+    }
+    get copyFailTip() {
+        return this.translate.get('tooltip_copy_failed');
+    }
+    static { this.ɵfac = function AuiTooltipCopyIntl_Factory(t) { return new (t || AuiTooltipCopyIntl)(i0.ɵɵinject(i1.TranslateService)); }; }
+    static { this.ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: AuiTooltipCopyIntl, factory: AuiTooltipCopyIntl.ɵfac }); }
+}
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(AuiTooltipCopyIntl, [{
+        type: Injectable
+    }], function () { return [{ type: i1.TranslateService }]; }, null); })();
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYXVpLXRvb2x0aXAtY29weS1pbnRsLnNlcnZpY2UuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9saWJzL2NvbW1vbi9zcmMvY29yZS9zZXJ2aWNlcy9hdWktdG9vbHRpcC1jb3B5LWludGwuc2VydmljZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsVUFBVSxFQUFFLE1BQU0sZUFBZSxDQUFDO0FBRTNDLE9BQU8sRUFBRSxnQkFBZ0IsRUFBRSxNQUFNLG1DQUFtQyxDQUFDOzs7QUFHckUsTUFBTSxPQUFPLGtCQUFrQjtJQUM3QixZQUE2QixTQUEyQjtRQUEzQixjQUFTLEdBQVQsU0FBUyxDQUFrQjtJQUFHLENBQUM7SUFFNUQsSUFBSSxPQUFPO1FBQ1QsT0FBTyxJQUFJLENBQUMsU0FBUyxDQUFDLEdBQUcsQ0FBQyw0QkFBNEIsQ0FBQyxDQUFDO0lBQzFELENBQUM7SUFFRCxJQUFJLGNBQWM7UUFDaEIsT0FBTyxJQUFJLENBQUMsU0FBUyxDQUFDLEdBQUcsQ0FBQyx3QkFBd0IsQ0FBQyxDQUFDO0lBQ3RELENBQUM7SUFFRCxJQUFJLFdBQVc7UUFDYixPQUFPLElBQUksQ0FBQyxTQUFTLENBQUMsR0FBRyxDQUFDLHFCQUFxQixDQUFDLENBQUM7SUFDbkQsQ0FBQzttRkFiVSxrQkFBa0I7dUVBQWxCLGtCQUFrQixXQUFsQixrQkFBa0I7O3VGQUFsQixrQkFBa0I7Y0FEOUIsVUFBVSIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IEluamVjdGFibGUgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcblxuaW1wb3J0IHsgVHJhbnNsYXRlU2VydmljZSB9IGZyb20gJy4uLy4uL3RyYW5zbGF0ZS90cmFuc2xhdGUuc2VydmljZSc7XG5cbkBJbmplY3RhYmxlKClcbmV4cG9ydCBjbGFzcyBBdWlUb29sdGlwQ29weUludGwge1xuICBjb25zdHJ1Y3Rvcihwcml2YXRlIHJlYWRvbmx5IHRyYW5zbGF0ZTogVHJhbnNsYXRlU2VydmljZSkge31cblxuICBnZXQgY29weVRpcCgpIHtcbiAgICByZXR1cm4gdGhpcy50cmFuc2xhdGUuZ2V0KCd0b29sdGlwX2NvcHlfY2xpY2tfdG9fY29weScpO1xuICB9XG5cbiAgZ2V0IGNvcHlTdWNjZXNzVGlwKCkge1xuICAgIHJldHVybiB0aGlzLnRyYW5zbGF0ZS5nZXQoJ3Rvb2x0aXBfY29weV9zdWNjZWVkZWQnKTtcbiAgfVxuXG4gIGdldCBjb3B5RmFpbFRpcCgpIHtcbiAgICByZXR1cm4gdGhpcy50cmFuc2xhdGUuZ2V0KCd0b29sdGlwX2NvcHlfZmFpbGVkJyk7XG4gIH1cbn1cbiJdfQ==

package/esm2022/core/services/context.service.mjs

@@ -0,0 +1,48 @@
+import { Inject, Injectable, InjectionToken } from '@angular/core';
+import { BehaviorSubject } from 'rxjs';
+import { publishRef } from '../utils';
+import * as i0 from "@angular/core";
+/**
+ * 用于跨组件共享状态
+ *
+ * 使用示例：
+ *   providers: [{
+ *     provide: CONTEXT_INIT_VALUE_TOKEN,
+ *     useValue: LOG_TIMESTAMP_RANGES[1]
+ *   }, {
+ *     provide: ContextService, // 可以通过不同的token隔离状态或使用具有语意的token来提高可读性等
+ *     useClass: ContextService,
+ *   }],
+ *
+ * 与业务无关，简单、纯粹，所以你可以在业务中实现多状态共享，例如
+ *    this.contextService.set({
+ *       ...this.contextService.get(),
+ *       step: 2
+ *     });
+ */
+export const CONTEXT_INIT_VALUE_TOKEN = new InjectionToken('CONTEXT_INIT_VALUE_TOKEN');
+export class ContextService {
+    constructor(initValue) {
+        this.initValue = initValue;
+        this.value$$ = new BehaviorSubject(this.initValue);
+        this.value$ = this.value$$.asObservable().pipe(publishRef());
+    }
+    set(value) {
+        this.value$$.next(value);
+    }
+    get() {
+        return this.value$$.getValue();
+    }
+    reset() {
+        this.set(this.initValue);
+    }
+    static { this.ɵfac = function ContextService_Factory(t) { return new (t || ContextService)(i0.ɵɵinject(CONTEXT_INIT_VALUE_TOKEN)); }; }
+    static { this.ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: ContextService, factory: ContextService.ɵfac }); }
+}
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(ContextService, [{
+        type: Injectable
+    }], function () { return [{ type: undefined, decorators: [{
+                type: Inject,
+                args: [CONTEXT_INIT_VALUE_TOKEN]
+            }] }]; }, null); })();
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/core/services/custom-code-editor-intl.service.mjs

@@ -0,0 +1,54 @@
+import { CodeEditorIntl } from '@alauda/code-editor';
+import { Injectable } from '@angular/core';
+import { mapValues, startCase } from 'lodash-es';
+import { map } from 'rxjs';
+import { publishRef } from '..';
+import { TranslateService } from '../../translate/translate.service';
+import * as i0 from "@angular/core";
+import * as i1 from "../../translate/translate.service";
+const CUSTOM_CODE_EDITOR_DEFAULT_LABELS = {
+    copyLabel: 'copy',
+    copiedLabel: 'code_editor_copied',
+    readonlyLabel: 'code_editor_readonly',
+    readwriteLabel: 'code_editor_writable',
+    clearLabel: 'clear',
+    recoverLabel: 'code_editor_recover',
+    findLabel: 'code_editor_find',
+    formatLabel: 'code_editor_format',
+    foldLabel: 'code_editor_fold',
+    exportLabel: 'code_editor_export',
+    importLabel: 'code_editor_import',
+    lightThemeLabel: 'code_editor_light_theme',
+    darkThemeLabel: 'code_editor_dark_theme',
+    autoThemeLabel: 'auto',
+    showDiffLabel: 'code_editor_show_diff',
+    fullscreenLabel: 'code_editor_fullscreen',
+    exitFullscreenLabel: 'code_editor_exit_fullscreen',
+    previewLabel: 'code_editor_preview_label',
+};
+/**
+ * aui-code-editor 中 label 翻译依赖 CodeEditorIntl 中的具体属性值
+ */
+export class CustomCodeEditorIntl extends CodeEditorIntl {
+    getLanguageLabel(lang) {
+        switch (lang) {
+            case 'yaml': {
+                return 'YAML';
+            }
+            default: {
+                return startCase(lang).replaceAll(' ', '');
+            }
+        }
+    }
+    constructor(translate) {
+        super();
+        this.translate = translate;
+        this.labels$ = this.translate.locale$.pipe(map(() => mapValues(CUSTOM_CODE_EDITOR_DEFAULT_LABELS, value => this.translate.get(value))), publishRef());
+    }
+    static { this.ɵfac = function CustomCodeEditorIntl_Factory(t) { return new (t || CustomCodeEditorIntl)(i0.ɵɵinject(i1.TranslateService)); }; }
+    static { this.ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: CustomCodeEditorIntl, factory: CustomCodeEditorIntl.ɵfac }); }
+}
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(CustomCodeEditorIntl, [{
+        type: Injectable
+    }], function () { return [{ type: i1.TranslateService }]; }, null); })();
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/core/services/feature-gate.service.mjs

@@ -0,0 +1,73 @@
+/**
+ * @packageDocumentation
+ * @module utils
+ */
+import { HttpClient } from '@angular/common/http';
+import { Injectable } from '@angular/core';
+import { filter as _filter } from 'lodash-es';
+import { of, catchError, map, startWith, shareReplay, take, } from 'rxjs';
+import { API_GATEWAY } from '../constants';
+import { CacheStore } from '../utils';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+const GlobalCluster = Symbol('Global Cluster');
+export class FeatureGateService {
+    constructor(http) {
+        this.http = http;
+        this.cacheStore = new CacheStore({
+            share: () => shareReplay(1),
+            idGenerator: (cluster) => cluster || GlobalCluster,
+            fetcher: (cluster) => {
+                const url = cluster
+                    ? `${API_GATEWAY}/fg/v1/${cluster}/featuregates`
+                    : `${API_GATEWAY}/fg/v1/featuregates`;
+                return this.http.get(url).pipe(map(({ items }) => items.reduce((acc, curr) => {
+                    acc[curr.metadata.name] = curr.status.enabled;
+                    return acc;
+                }, {})), catchError(() => of({})));
+            },
+        });
+    }
+    loadState(cluster) {
+        return this.cacheStore.fetchState(cluster).pipe(map(load => load.state));
+    }
+    /**
+     * check gate status
+     * @param gate - specified feature gate
+     * @param cluster - check gate for specified cluster
+     */
+    isEnabled(gateName, cluster) {
+        return this.cacheStore.fetch(cluster).pipe(map(v => !!v[gateName]), take(1));
+    }
+    /**
+     * filter list with gate, send items without feature gate as begin push (can skip by passing `skipNoFeatureGatePush` argument with true)
+     * @param items - list need filter
+     * @param gateAccessor - how to get gate from item
+     * @param cluster - check gate for specified cluster
+     * @param filterMethod - filter method, default to list filter, can filter deep with createRecursiveFilter or totally custom method.
+     * @param skipNoFeatureGatePush - skip begin push , default false.
+     */
+    filterEnabled(items, gateAccessor, cluster, filterMethod = _filter, skipNoFeatureGatePush = false) {
+        const filtered = this.cacheStore.fetch(cluster).pipe(map(v => filterMethod(items, item => {
+            const gate = gateAccessor(item);
+            return gate ? !!v[gate] : true;
+        })));
+        return skipNoFeatureGatePush
+            ? filtered
+            : filtered.pipe(startWith(filterMethod(items, item => !gateAccessor(item))));
+    }
+    /**
+     * refetch cached feature gate settings
+     * @param cluster - specified cluster, refetch all already cached settings when cluster is empty
+     */
+    refetchCache(cluster) {
+        this.cacheStore.refetch(cluster);
+    }
+    static { this.ɵfac = function FeatureGateService_Factory(t) { return new (t || FeatureGateService)(i0.ɵɵinject(i1.HttpClient)); }; }
+    static { this.ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: FeatureGateService, factory: FeatureGateService.ɵfac, providedIn: 'root' }); }
+}
+(function () { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(FeatureGateService, [{
+        type: Injectable,
+        args: [{ providedIn: 'root' }]
+    }], function () { return [{ type: i1.HttpClient }]; }, null); })();
+//# sourceMappingURL=data:application/json;base64,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