@delon/abc 15.2.1 → 16.0.0

package/esm2022/lodop/lodop.service.mjs

@@ -0,0 +1,223 @@
+import { Injectable } from '@angular/core';
+import { of, Subject } from 'rxjs';
+import * as i0 from "@angular/core";
+import * as i1 from "@delon/util/other";
+import * as i2 from "@delon/util/config";
+class LodopService {
+    constructor(scriptSrv, configSrv) {
+        this.scriptSrv = scriptSrv;
+        this.pending = false;
+        this._lodop = null;
+        this._init = new Subject();
+        this._events = new Subject();
+        this.printBuffer = [];
+        this.defaultConfig = configSrv.merge('lodop', {
+            url: '//localhost:8443/CLodopfuncs.js',
+            name: 'CLODOP',
+            companyName: '',
+            checkMaxCount: 100
+        });
+        this.cog = this.defaultConfig;
+    }
+    /**
+     * Get or set configuration, **Note:** Resetting will invert and reload script resources
+     *
+     * 获取或重新设置配置，**注：**重新设置会倒置重新加载脚本资源
+     */
+    get cog() {
+        return this._cog;
+    }
+    set cog(value) {
+        this._cog = {
+            ...this.defaultConfig,
+            ...value
+        };
+    }
+    /**
+     * Event change notification
+     *
+     * 事件变更通知
+     */
+    get events() {
+        return this._events.asObservable();
+    }
+    /**
+     * Get lodop object
+     *
+     * 获取 lodop 对象
+     */
+    get lodop() {
+        if (this._lodop)
+            return of({ ok: true, lodop: this._lodop });
+        if (this.pending)
+            return this._init.asObservable();
+        this.request();
+        return this._init.asObservable();
+    }
+    /**
+     * Get printer list
+     *
+     * 获取打印机列表
+     */
+    get printer() {
+        this.check();
+        const ret = [];
+        const count = this._lodop.GET_PRINTER_COUNT();
+        for (let index = 0; index < count; index++) {
+            ret.push(this._lodop.GET_PRINTER_NAME(index));
+        }
+        return ret;
+    }
+    check() {
+        if (!this._lodop)
+            throw new Error(`请务必先调用 lodop 获取对象`);
+    }
+    request() {
+        this.pending = true;
+        const url = `${this.cog.url}?name=${this.cog.name}`;
+        let checkMaxCount = this.cog.checkMaxCount;
+        const onResolve = (status, error) => {
+            this._init.next({
+                ok: status === 'ok',
+                status,
+                error,
+                lodop: this._lodop
+            });
+        };
+        const checkStatus = () => {
+            --checkMaxCount;
+            if (this._lodop.webskt && this._lodop.webskt.readyState === 1) {
+                onResolve('ok');
+            }
+            else {
+                if (checkMaxCount < 0) {
+                    onResolve('check-limit');
+                    return;
+                }
+                setTimeout(() => checkStatus(), 100);
+            }
+        };
+        this.scriptSrv.loadScript(url).then((res) => {
+            if (res.status !== 'ok') {
+                this.pending = false;
+                onResolve('script-load-error', res[0]);
+                return;
+            }
+            const win = window;
+            if (win.hasOwnProperty(this.cog.name)) {
+                this._lodop = win[this.cog.name];
+            }
+            if (this._lodop === null) {
+                onResolve('load-variable-name-error', { name: this.cog.name });
+                return;
+            }
+            this._lodop.SET_LICENSES(this.cog.companyName, this.cog.license, this.cog.licenseA, this.cog.licenseB);
+            checkStatus();
+        });
+    }
+    /**
+     * Reset lodop object
+     *
+     * 重置 lodop 对象
+     */
+    reset() {
+        this._lodop = null;
+        this.pending = false;
+        this.request();
+    }
+    /**
+     * Attach code to the `lodop` object, the string class supports dynamic parameters of `{{key}}`,
+     * **Note:** The code refers to the string data generated by the print design
+     *
+     * 附加代码至 `lodop` 对象上，字符串类支持 `{{key}}` 的动态参数，**注：** 代码是指打印设计所产生字符串数据
+     */
+    attachCode(code, contextObj, parser) {
+        this.check();
+        if (!parser)
+            parser = /LODOP\.([^(]+)\(([^\n]+)?\);/i;
+        code.split('\n').forEach(line => {
+            const res = parser.exec(line.trim());
+            if (!res)
+                return;
+            const fn = this._lodop[res[1]];
+            if (fn) {
+                let arr = null;
+                try {
+                    const fakeFn = new Function(`return [${res[2]}]`);
+                    arr = fakeFn();
+                }
+                catch { }
+                if (arr != null && Array.isArray(arr) && contextObj) {
+                    for (let i = 0; i < arr.length; i++) {
+                        if (typeof arr[i] === 'string') {
+                            arr[i] = arr[i].replace(/{{(.*?)}}/g, (_match, key) => contextObj[key.trim()] || '');
+                        }
+                    }
+                }
+                fn.apply(this._lodop, arr);
+            }
+        });
+    }
+    /**
+     * The code is automatically returned after opening the print design and closing,
+     * **Note:** Automatically listen for the `On_Return` event, and it will be removed after running
+     *
+     * 打开打印设计关闭后自动返回代码，**注：** 自动监听 `On_Return` 事件，运行后会移除
+     */
+    design() {
+        this.check();
+        const tid = this._lodop.PRINT_DESIGN();
+        return new Promise(resolve => {
+            this._lodop.On_Return = (taskID, value) => {
+                if (tid !== taskID)
+                    return;
+                this._lodop.On_Return = null;
+                resolve(`${value}`);
+            };
+        });
+    }
+    printDo() {
+        const data = this.printBuffer.shift();
+        if (!data)
+            return;
+        this.attachCode(data.code, data.item, data.parser);
+        const tid = this._lodop.PRINT();
+        this._lodop.On_Return = (taskID, value) => {
+            if (tid !== taskID)
+                return;
+            this._lodop.On_Return = null;
+            this._events.next({
+                ok: value === true,
+                error: value === true ? null : value,
+                ...data
+            });
+            this.printDo();
+        };
+    }
+    /**
+     * Print immediately, generally used for batch printing
+     *
+     * 立即打印，一般用于批量套打
+     */
+    print(code, contextObj, parser) {
+        this.check();
+        if (contextObj) {
+            this.printBuffer.push(...(Array.isArray(contextObj) ? contextObj : [contextObj]).map(item => {
+                return { code, parser, item };
+            }));
+        }
+        this.printDo();
+    }
+    ngOnDestroy() {
+        this._init.unsubscribe();
+        this._events.unsubscribe();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.4", ngImport: i0, type: LodopService, deps: [{ token: i1.LazyService }, { token: i2.AlainConfigService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.0.4", ngImport: i0, type: LodopService, providedIn: 'root' }); }
+}
+export { LodopService };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.4", ngImport: i0, type: LodopService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: function () { return [{ type: i1.LazyService }, { type: i2.AlainConfigService }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"lodop.service.js","sourceRoot":"","sources":["../../../../../packages/abc/lodop/lodop.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable, OnDestroy } from '@angular/core';\nimport { Observable, of, Subject } from 'rxjs';\n\nimport { AlainConfigService, AlainLodopConfig } from '@delon/util/config';\nimport { LazyService } from '@delon/util/other';\nimport type { NzSafeAny } from 'ng-zorro-antd/core/types';\n\nimport { Lodop, LodopPrintResult, LodopResult } from './lodop.types';\n\n@Injectable({ providedIn: 'root' })\nexport class LodopService implements OnDestroy {\n  private defaultConfig: AlainLodopConfig;\n  private _cog!: AlainLodopConfig;\n  private pending = false;\n  private _lodop: Lodop | null = null;\n  private _init = new Subject<LodopResult>();\n  private _events = new Subject<LodopPrintResult>();\n  private printBuffer: NzSafeAny[] = [];\n\n  constructor(private scriptSrv: LazyService, configSrv: AlainConfigService) {\n    this.defaultConfig = configSrv.merge('lodop', {\n      url: '//localhost:8443/CLodopfuncs.js',\n      name: 'CLODOP',\n      companyName: '',\n      checkMaxCount: 100\n    })!;\n    this.cog = this.defaultConfig;\n  }\n\n  /**\n   * Get or set configuration, **Note:** Resetting will invert and reload script resources\n   *\n   * 获取或重新设置配置，**注：**重新设置会倒置重新加载脚本资源\n   */\n  get cog(): AlainLodopConfig {\n    return this._cog;\n  }\n  set cog(value: AlainLodopConfig) {\n    this._cog = {\n      ...this.defaultConfig,\n      ...value\n    };\n  }\n\n  /**\n   * Event change notification\n   *\n   * 事件变更通知\n   */\n  get events(): Observable<LodopPrintResult> {\n    return this._events.asObservable();\n  }\n\n  /**\n   * Get lodop object\n   *\n   * 获取 lodop 对象\n   */\n  get lodop(): Observable<LodopResult> {\n    if (this._lodop) return of({ ok: true, lodop: this._lodop } as LodopResult);\n    if (this.pending) return this._init.asObservable();\n\n    this.request();\n\n    return this._init.asObservable();\n  }\n\n  /**\n   * Get printer list\n   *\n   * 获取打印机列表\n   */\n  get printer(): string[] {\n    this.check();\n    const ret: string[] = [];\n    const count = this._lodop!.GET_PRINTER_COUNT();\n    for (let index = 0; index < count; index++) {\n      ret.push(this._lodop!.GET_PRINTER_NAME(index));\n    }\n    return ret;\n  }\n\n  private check(): void {\n    if (!this._lodop) throw new Error(`请务必先调用 lodop 获取对象`);\n  }\n\n  private request(): void {\n    this.pending = true;\n\n    const url = `${this.cog.url}?name=${this.cog.name}`;\n    let checkMaxCount = this.cog.checkMaxCount as number;\n    const onResolve = (status: NzSafeAny, error?: NzSafeAny): void => {\n      this._init.next({\n        ok: status === 'ok',\n        status,\n        error,\n        lodop: this._lodop!\n      });\n    };\n    const checkStatus = (): void => {\n      --checkMaxCount;\n      if (this._lodop!.webskt && this._lodop!.webskt.readyState === 1) {\n        onResolve('ok');\n      } else {\n        if (checkMaxCount < 0) {\n          onResolve('check-limit');\n          return;\n        }\n        setTimeout(() => checkStatus(), 100);\n      }\n    };\n\n    this.scriptSrv.loadScript(url).then((res: NzSafeAny) => {\n      if (res.status !== 'ok') {\n        this.pending = false;\n        onResolve('script-load-error', res[0]);\n        return;\n      }\n      const win = window as NzSafeAny;\n      if (win.hasOwnProperty(this.cog.name!)) {\n        this._lodop = win[this.cog.name!] as Lodop;\n      }\n      if (this._lodop === null) {\n        onResolve('load-variable-name-error', { name: this.cog.name });\n        return;\n      }\n      this._lodop.SET_LICENSES(this.cog.companyName!, this.cog.license!, this.cog.licenseA, this.cog.licenseB);\n      checkStatus();\n    });\n  }\n\n  /**\n   * Reset lodop object\n   *\n   * 重置 lodop 对象\n   */\n  reset(): void {\n    this._lodop = null;\n    this.pending = false;\n    this.request();\n  }\n\n  /**\n   * Attach code to the `lodop` object, the string class supports dynamic parameters of `{{key}}`,\n   * **Note:** The code refers to the string data generated by the print design\n   *\n   * 附加代码至 `lodop` 对象上，字符串类支持 `{{key}}` 的动态参数，**注：** 代码是指打印设计所产生字符串数据\n   */\n  attachCode(code: string, contextObj?: NzSafeAny, parser?: RegExp): void {\n    this.check();\n    if (!parser) parser = /LODOP\\.([^(]+)\\(([^\\n]+)?\\);/i;\n    code.split('\\n').forEach(line => {\n      const res = parser!.exec(line.trim());\n      if (!res) return;\n      const fn = this._lodop![res[1]];\n      if (fn) {\n        let arr: NzSafeAny[] | null = null;\n        try {\n          const fakeFn = new Function(`return [${res[2]}]`);\n          arr = fakeFn();\n        } catch {}\n\n        if (arr != null && Array.isArray(arr) && contextObj) {\n          for (let i = 0; i < arr.length; i++) {\n            if (typeof arr[i] === 'string') {\n              arr[i] = (arr[i] as string).replace(/{{(.*?)}}/g, (_match, key) => contextObj[key.trim()] || '');\n            }\n          }\n        }\n        fn.apply(this._lodop, arr!);\n      }\n    });\n  }\n\n  /**\n   * The code is automatically returned after opening the print design and closing,\n   * **Note:** Automatically listen for the `On_Return` event, and it will be removed after running\n   *\n   * 打开打印设计关闭后自动返回代码，**注：** 自动监听 `On_Return` 事件，运行后会移除\n   */\n  design(): Promise<string> {\n    this.check();\n    const tid = this._lodop!.PRINT_DESIGN();\n    return new Promise(resolve => {\n      this._lodop!.On_Return = (taskID: string, value: boolean | string) => {\n        if (tid !== taskID) return;\n        this._lodop!.On_Return = null;\n        resolve(`${value}`);\n      };\n    });\n  }\n  private printDo(): void {\n    const data = this.printBuffer.shift();\n    if (!data) return;\n    this.attachCode(data.code, data.item, data.parser);\n    const tid = this._lodop!.PRINT();\n    this._lodop!.On_Return = (taskID: string, value: boolean | string) => {\n      if (tid !== taskID) return;\n      this._lodop!.On_Return = null;\n      this._events.next({\n        ok: value === true,\n        error: value === true ? null : value,\n        ...data\n      });\n      this.printDo();\n    };\n  }\n\n  /**\n   * Print immediately, generally used for batch printing\n   *\n   * 立即打印，一般用于批量套打\n   */\n  print(code: string, contextObj: NzSafeAny, parser?: RegExp): void {\n    this.check();\n    if (contextObj) {\n      this.printBuffer.push(\n        ...(Array.isArray(contextObj) ? contextObj : [contextObj]).map(item => {\n          return { code, parser, item };\n        })\n      );\n    }\n    this.printDo();\n  }\n\n  ngOnDestroy(): void {\n    this._init.unsubscribe();\n    this._events.unsubscribe();\n  }\n}\n"]}

package/esm2022/media/media.component.mjs

@@ -0,0 +1,118 @@
+import { __decorate } from "tslib";
+import { ChangeDetectionStrategy, Component, EventEmitter, Input, Output, ViewEncapsulation } from '@angular/core';
+import { Subject, timer, takeUntil, take } from 'rxjs';
+import { InputNumber, ZoneOutside } from '@delon/util/decorator';
+import * as i0 from "@angular/core";
+import * as i1 from "./media.service";
+import * as i2 from "@angular/cdk/platform";
+class MediaComponent {
+    get player() {
+        return this._p;
+    }
+    constructor(el, renderer, srv, ngZone, platform) {
+        this.el = el;
+        this.renderer = renderer;
+        this.srv = srv;
+        this.ngZone = ngZone;
+        this.platform = platform;
+        this.destroy$ = new Subject();
+        this.type = 'video';
+        this.delay = 0;
+        this.ready = new EventEmitter();
+    }
+    initDelay() {
+        timer(this.delay)
+            .pipe(takeUntil(this.destroy$))
+            .subscribe(() => this.ngZone.runOutsideAngular(() => this.init()));
+    }
+    init() {
+        const winPlyr = window.Plyr;
+        if (!winPlyr) {
+            throw new Error(`No window.Plyr found, please make sure that cdn or local path exists, the current referenced path is: ${JSON.stringify(this.srv.cog.urls)}`);
+        }
+        this.ensureElement();
+        const player = (this._p = new winPlyr(this.videoEl, {
+            ...this.srv.cog.options
+        }));
+        player.on('ready', () => this.ngZone.run(() => this.ready.next(player)));
+        this.uploadSource();
+    }
+    ensureElement() {
+        const { type } = this;
+        let el = this.el.nativeElement.querySelector(type);
+        if (!el) {
+            el = this.renderer.createElement(type);
+            el.controls = true;
+            this.el.nativeElement.appendChild(el);
+        }
+        this.videoEl = el;
+    }
+    destroy() {
+        if (this._p) {
+            this._p.destroy();
+        }
+    }
+    uploadSource() {
+        if (this._p == null)
+            return;
+        const { source, type } = this;
+        this._p.source = (typeof source === 'string' ? { type, sources: [{ src: source }] } : source);
+    }
+    ngAfterViewInit() {
+        if (!this.platform.isBrowser) {
+            return;
+        }
+        this.srv
+            .notify()
+            .pipe(takeUntil(this.destroy$), take(1))
+            .subscribe(() => this.initDelay());
+        this.srv.load();
+    }
+    ngOnChanges(changes) {
+        this.srv.cog = { options: this.options };
+        if (changes.source) {
+            this.uploadSource();
+        }
+    }
+    ngOnDestroy() {
+        this.destroy();
+        this._p = null;
+        const { destroy$ } = this;
+        destroy$.next();
+        destroy$.complete();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.4", ngImport: i0, type: MediaComponent, deps: [{ token: i0.ElementRef }, { token: i0.Renderer2 }, { token: i1.MediaService }, { token: i0.NgZone }, { token: i2.Platform }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.0.4", type: MediaComponent, selector: "media", inputs: { type: "type", source: "source", options: "options", delay: "delay" }, outputs: { ready: "ready" }, host: { properties: { "style.display": "'block'" } }, exportAs: ["mediaComponent"], usesOnChanges: true, ngImport: i0, template: `<ng-content></ng-content>`, isInline: true, changeDetection: i0.ChangeDetectionStrategy.OnPush, encapsulation: i0.ViewEncapsulation.None }); }
+}
+__decorate([
+    InputNumber()
+], MediaComponent.prototype, "delay", void 0);
+__decorate([
+    ZoneOutside()
+], MediaComponent.prototype, "initDelay", null);
+export { MediaComponent };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.4", ngImport: i0, type: MediaComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'media',
+                    exportAs: 'mediaComponent',
+                    template: `<ng-content></ng-content>`,
+                    host: {
+                        '[style.display]': `'block'`
+                    },
+                    preserveWhitespaces: false,
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    encapsulation: ViewEncapsulation.None
+                }]
+        }], ctorParameters: function () { return [{ type: i0.ElementRef }, { type: i0.Renderer2 }, { type: i1.MediaService }, { type: i0.NgZone }, { type: i2.Platform }]; }, propDecorators: { type: [{
+                type: Input
+            }], source: [{
+                type: Input
+            }], options: [{
+                type: Input
+            }], delay: [{
+                type: Input
+            }], ready: [{
+                type: Output
+            }], initDelay: [] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"media.component.js","sourceRoot":"","sources":["../../../../../packages/abc/media/media.component.ts"],"names":[],"mappings":"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","sourcesContent":["import { Platform } from '@angular/cdk/platform';\nimport {\n  AfterViewInit,\n  ChangeDetectionStrategy,\n  Component,\n  ElementRef,\n  EventEmitter,\n  Input,\n  NgZone,\n  OnChanges,\n  OnDestroy,\n  Output,\n  Renderer2,\n  SimpleChange,\n  ViewEncapsulation\n} from '@angular/core';\nimport { Subject, timer, takeUntil, take } from 'rxjs';\n\nimport type Plyr from 'plyr';\n\nimport { InputNumber, NumberInput, ZoneOutside } from '@delon/util/decorator';\nimport type { NzSafeAny } from 'ng-zorro-antd/core/types';\n\nimport { MediaService } from './media.service';\n\nexport type MediaType = 'html5' | 'youtube' | 'video' | 'audio';\n\n@Component({\n  selector: 'media',\n  exportAs: 'mediaComponent',\n  template: `<ng-content></ng-content>`,\n  host: {\n    '[style.display]': `'block'`\n  },\n  preserveWhitespaces: false,\n  changeDetection: ChangeDetectionStrategy.OnPush,\n  encapsulation: ViewEncapsulation.None\n})\nexport class MediaComponent implements OnChanges, AfterViewInit, OnDestroy {\n  static ngAcceptInputType_delay: NumberInput;\n\n  private _p?: Plyr | null;\n  private videoEl?: HTMLElement;\n  private destroy$ = new Subject<void>();\n\n  @Input() type: MediaType = 'video';\n  @Input() source?: string | Plyr.SourceInfo;\n  @Input() options?: Plyr.Options;\n  @Input() @InputNumber() delay = 0;\n  @Output() readonly ready = new EventEmitter<Plyr>();\n\n  get player(): Plyr | undefined | null {\n    return this._p;\n  }\n\n  constructor(\n    private el: ElementRef<HTMLElement>,\n    private renderer: Renderer2,\n    private srv: MediaService,\n    private ngZone: NgZone,\n    private platform: Platform\n  ) {}\n\n  @ZoneOutside()\n  private initDelay(): void {\n    timer(this.delay)\n      .pipe(takeUntil(this.destroy$))\n      .subscribe(() => this.ngZone.runOutsideAngular(() => this.init()));\n  }\n\n  private init(): void {\n    const winPlyr = (window as NzSafeAny).Plyr;\n    if (!winPlyr) {\n      throw new Error(\n        `No window.Plyr found, please make sure that cdn or local path exists, the current referenced path is: ${JSON.stringify(\n          this.srv.cog.urls\n        )}`\n      );\n    }\n\n    this.ensureElement();\n\n    const player: Plyr = (this._p = new winPlyr(this.videoEl, {\n      ...this.srv.cog.options\n    }));\n\n    player.on('ready', () => this.ngZone.run(() => this.ready.next(player)));\n\n    this.uploadSource();\n  }\n\n  private ensureElement(): void {\n    const { type } = this;\n    let el = this.el.nativeElement.querySelector(type) as HTMLElement;\n    if (!el) {\n      el = this.renderer.createElement(type);\n      (el as HTMLVideoElement).controls = true;\n      this.el.nativeElement.appendChild(el);\n    }\n    this.videoEl = el;\n  }\n\n  private destroy(): void {\n    if (this._p) {\n      this._p.destroy();\n    }\n  }\n\n  private uploadSource(): void {\n    if (this._p == null) return;\n\n    const { source, type } = this;\n    this._p.source = (typeof source === 'string' ? { type, sources: [{ src: source }] } : source) as Plyr.SourceInfo;\n  }\n\n  ngAfterViewInit(): void {\n    if (!this.platform.isBrowser) {\n      return;\n    }\n    this.srv\n      .notify()\n      .pipe(takeUntil(this.destroy$), take(1))\n      .subscribe(() => this.initDelay());\n\n    this.srv.load();\n  }\n\n  ngOnChanges(changes: { [p in keyof MediaComponent]?: SimpleChange }): void {\n    this.srv.cog = { options: this.options };\n    if (changes.source) {\n      this.uploadSource();\n    }\n  }\n\n  ngOnDestroy(): void {\n    this.destroy();\n    this._p = null;\n\n    const { destroy$ } = this;\n    destroy$.next();\n    destroy$.complete();\n  }\n}\n"]}

package/esm2022/media/media.module.mjs

@@ -0,0 +1,20 @@
+import { CommonModule } from '@angular/common';
+import { NgModule } from '@angular/core';
+import { MediaComponent } from './media.component';
+import * as i0 from "@angular/core";
+const COMPONENTS = [MediaComponent];
+class MediaModule {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.4", ngImport: i0, type: MediaModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "16.0.4", ngImport: i0, type: MediaModule, declarations: [MediaComponent], imports: [CommonModule], exports: [MediaComponent] }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "16.0.4", ngImport: i0, type: MediaModule, imports: [CommonModule] }); }
+}
+export { MediaModule };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.4", ngImport: i0, type: MediaModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [CommonModule],
+                    declarations: COMPONENTS,
+                    exports: COMPONENTS
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibWVkaWEubW9kdWxlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vcGFja2FnZXMvYWJjL21lZGlhL21lZGlhLm1vZHVsZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsWUFBWSxFQUFFLE1BQU0saUJBQWlCLENBQUM7QUFDL0MsT0FBTyxFQUFFLFFBQVEsRUFBRSxNQUFNLGVBQWUsQ0FBQztBQUV6QyxPQUFPLEVBQUUsY0FBYyxFQUFFLE1BQU0sbUJBQW1CLENBQUM7O0FBRW5ELE1BQU0sVUFBVSxHQUFHLENBQUMsY0FBYyxDQUFDLENBQUM7QUFFcEMsTUFLYSxXQUFXOzhHQUFYLFdBQVc7K0dBQVgsV0FBVyxpQkFQSixjQUFjLGFBR3RCLFlBQVksYUFISixjQUFjOytHQU9yQixXQUFXLFlBSlosWUFBWTs7U0FJWCxXQUFXOzJGQUFYLFdBQVc7a0JBTHZCLFFBQVE7bUJBQUM7b0JBQ1IsT0FBTyxFQUFFLENBQUMsWUFBWSxDQUFDO29CQUN2QixZQUFZLEVBQUUsVUFBVTtvQkFDeEIsT0FBTyxFQUFFLFVBQVU7aUJBQ3BCIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgQ29tbW9uTW9kdWxlIH0gZnJvbSAnQGFuZ3VsYXIvY29tbW9uJztcbmltcG9ydCB7IE5nTW9kdWxlIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5cbmltcG9ydCB7IE1lZGlhQ29tcG9uZW50IH0gZnJvbSAnLi9tZWRpYS5jb21wb25lbnQnO1xuXG5jb25zdCBDT01QT05FTlRTID0gW01lZGlhQ29tcG9uZW50XTtcblxuQE5nTW9kdWxlKHtcbiAgaW1wb3J0czogW0NvbW1vbk1vZHVsZV0sXG4gIGRlY2xhcmF0aW9uczogQ09NUE9ORU5UUyxcbiAgZXhwb3J0czogQ09NUE9ORU5UU1xufSlcbmV4cG9ydCBjbGFzcyBNZWRpYU1vZHVsZSB7fVxuIl19

package/esm2022/media/media.service.mjs

@@ -0,0 +1,47 @@
+import { Injectable } from '@angular/core';
+import { Subject, share } from 'rxjs';
+import * as i0 from "@angular/core";
+import * as i1 from "@delon/util/config";
+import * as i2 from "@delon/util/other";
+class MediaService {
+    get cog() {
+        return this._cog;
+    }
+    set cog(val) {
+        this._cog = this.cogSrv.merge('media', {
+            urls: ['https://cdn.jsdelivr.net/npm/plyr/dist/plyr.min.js', 'https://cdn.jsdelivr.net/npm/plyr/dist/plyr.css']
+        }, val);
+    }
+    constructor(cogSrv, lazySrv) {
+        this.cogSrv = cogSrv;
+        this.lazySrv = lazySrv;
+        this.loading = false;
+        this.loaded = false;
+        this.notify$ = new Subject();
+    }
+    load() {
+        if (this.loading) {
+            if (this.loaded) {
+                this.notify$.next();
+            }
+            return this;
+        }
+        this.loading = true;
+        this.lazySrv.load(this.cog.urls).then(() => {
+            this.loaded = true;
+            this.notify$.next();
+        });
+        return this;
+    }
+    notify() {
+        return this.notify$.asObservable().pipe(share());
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.4", ngImport: i0, type: MediaService, deps: [{ token: i1.AlainConfigService }, { token: i2.LazyService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "16.0.4", ngImport: i0, type: MediaService, providedIn: 'root' }); }
+}
+export { MediaService };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.4", ngImport: i0, type: MediaService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: function () { return [{ type: i1.AlainConfigService }, { type: i2.LazyService }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/notice-icon/notice-icon-tab.component.mjs

@@ -0,0 +1,35 @@
+import { Component, EventEmitter, Input, Output, ViewEncapsulation } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+import * as i2 from "ng-zorro-antd/list";
+import * as i3 from "ng-zorro-antd/tag";
+import * as i4 from "ng-zorro-antd/core/outlet";
+class NoticeIconTabComponent {
+    constructor() {
+        this.locale = {};
+        this.select = new EventEmitter();
+        this.clear = new EventEmitter();
+    }
+    onClick(item) {
+        this.select.emit({ title: this.data.title, item });
+    }
+    onClear() {
+        this.clear.emit(this.data.title);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.4", ngImport: i0, type: NoticeIconTabComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.0.4", type: NoticeIconTabComponent, selector: "notice-icon-tab", inputs: { locale: "locale", data: "data" }, outputs: { select: "select", clear: "clear" }, exportAs: ["noticeIconTab"], ngImport: i0, template: "<div *ngIf=\"data.list?.length === 0; else listTpl\" class=\"notice-icon__notfound\">\n  <img class=\"notice-icon__notfound-img\" *ngIf=\"data.emptyImage\" [attr.src]=\"data.emptyImage\" alt=\"not found\" />\n  <p>\n    <ng-container *nzStringTemplateOutlet=\"data.emptyText\">\n      {{ data.emptyText || locale.emptyText }}\n    </ng-container>\n  </p>\n</div>\n<ng-template #listTpl>\n  <nz-list [nzDataSource]=\"data.list\" [nzRenderItem]=\"item\">\n    <ng-template #item let-item>\n      <nz-list-item (click)=\"onClick(item)\" [ngClass]=\"{ 'notice-icon__item-read': item.read }\">\n        <nz-list-item-meta [nzTitle]=\"nzTitle\" [nzDescription]=\"nzDescription\" [nzAvatar]=\"item.avatar\">\n          <ng-template #nzTitle>\n            <ng-container *nzStringTemplateOutlet=\"item.title; context: { $implicit: item }\">{{\n              item.title\n            }}</ng-container>\n            <div class=\"notice-icon__item-extra\" *ngIf=\"item.extra\">\n              <nz-tag [nzColor]=\"item.color\">{{ item.extra }}</nz-tag>\n            </div>\n          </ng-template>\n          <ng-template #nzDescription>\n            <div *ngIf=\"item.description\" class=\"notice-icon__item-desc\">\n              <ng-container *nzStringTemplateOutlet=\"item.description; context: { $implicit: item }\">{{\n                item.description\n              }}</ng-container>\n            </div>\n            <div *ngIf=\"item.datetime\" class=\"notice-icon__item-time\">{{ item.datetime }}</div>\n          </ng-template>\n        </nz-list-item-meta>\n      </nz-list-item>\n    </ng-template>\n  </nz-list>\n  <div class=\"notice-icon__clear\" (click)=\"onClear()\">{{ data.clearText || locale.clearText }}</div>\n</ng-template>\n", dependencies: [{ kind: "directive", type: i1.NgClass, selector: "[ngClass]", inputs: ["class", "ngClass"] }, { kind: "directive", type: i1.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "component", type: i2.NzListComponent, selector: "nz-list, [nz-list]", inputs: ["nzDataSource", "nzBordered", "nzGrid", "nzHeader", "nzFooter", "nzItemLayout", "nzRenderItem", "nzLoading", "nzLoadMore", "nzPagination", "nzSize", "nzSplit", "nzNoResult"], exportAs: ["nzList"] }, { kind: "component", type: i2.NzListItemComponent, selector: "nz-list-item, [nz-list-item]", inputs: ["nzActions", "nzContent", "nzExtra", "nzNoFlex"], exportAs: ["nzListItem"] }, { kind: "component", type: i2.NzListItemMetaComponent, selector: "nz-list-item-meta, [nz-list-item-meta]", inputs: ["nzAvatar", "nzTitle", "nzDescription"], exportAs: ["nzListItemMeta"] }, { kind: "component", type: i3.NzTagComponent, selector: "nz-tag", inputs: ["nzMode", "nzColor", "nzChecked"], outputs: ["nzOnClose", "nzCheckedChange"], exportAs: ["nzTag"] }, { kind: "directive", type: i4.NzStringTemplateOutletDirective, selector: "[nzStringTemplateOutlet]", inputs: ["nzStringTemplateOutletContext", "nzStringTemplateOutlet"], exportAs: ["nzStringTemplateOutlet"] }], encapsulation: i0.ViewEncapsulation.None }); }
+}
+export { NoticeIconTabComponent };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.4", ngImport: i0, type: NoticeIconTabComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'notice-icon-tab', exportAs: 'noticeIconTab', preserveWhitespaces: false, encapsulation: ViewEncapsulation.None, template: "<div *ngIf=\"data.list?.length === 0; else listTpl\" class=\"notice-icon__notfound\">\n  <img class=\"notice-icon__notfound-img\" *ngIf=\"data.emptyImage\" [attr.src]=\"data.emptyImage\" alt=\"not found\" />\n  <p>\n    <ng-container *nzStringTemplateOutlet=\"data.emptyText\">\n      {{ data.emptyText || locale.emptyText }}\n    </ng-container>\n  </p>\n</div>\n<ng-template #listTpl>\n  <nz-list [nzDataSource]=\"data.list\" [nzRenderItem]=\"item\">\n    <ng-template #item let-item>\n      <nz-list-item (click)=\"onClick(item)\" [ngClass]=\"{ 'notice-icon__item-read': item.read }\">\n        <nz-list-item-meta [nzTitle]=\"nzTitle\" [nzDescription]=\"nzDescription\" [nzAvatar]=\"item.avatar\">\n          <ng-template #nzTitle>\n            <ng-container *nzStringTemplateOutlet=\"item.title; context: { $implicit: item }\">{{\n              item.title\n            }}</ng-container>\n            <div class=\"notice-icon__item-extra\" *ngIf=\"item.extra\">\n              <nz-tag [nzColor]=\"item.color\">{{ item.extra }}</nz-tag>\n            </div>\n          </ng-template>\n          <ng-template #nzDescription>\n            <div *ngIf=\"item.description\" class=\"notice-icon__item-desc\">\n              <ng-container *nzStringTemplateOutlet=\"item.description; context: { $implicit: item }\">{{\n                item.description\n              }}</ng-container>\n            </div>\n            <div *ngIf=\"item.datetime\" class=\"notice-icon__item-time\">{{ item.datetime }}</div>\n          </ng-template>\n        </nz-list-item-meta>\n      </nz-list-item>\n    </ng-template>\n  </nz-list>\n  <div class=\"notice-icon__clear\" (click)=\"onClear()\">{{ data.clearText || locale.clearText }}</div>\n</ng-template>\n" }]
+        }], propDecorators: { locale: [{
+                type: Input
+            }], data: [{
+                type: Input
+            }], select: [{
+                type: Output
+            }], clear: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/notice-icon/notice-icon.component.mjs

@@ -0,0 +1,90 @@
+import { __decorate } from "tslib";
+import { ChangeDetectionStrategy, Component, EventEmitter, Input, Output, ViewEncapsulation } from '@angular/core';
+import { InputBoolean, InputNumber } from '@delon/util/decorator';
+import * as i0 from "@angular/core";
+import * as i1 from "@delon/theme";
+import * as i2 from "@angular/common";
+import * as i3 from "ng-zorro-antd/badge";
+import * as i4 from "ng-zorro-antd/dropdown";
+import * as i5 from "ng-zorro-antd/icon";
+import * as i6 from "ng-zorro-antd/spin";
+import * as i7 from "ng-zorro-antd/tabs";
+import * as i8 from "./notice-icon-tab.component";
+class NoticeIconComponent {
+    get overlayCls() {
+        return `header-dropdown notice-icon${!this.centered ? ' notice-icon__tab-left' : ''}`;
+    }
+    constructor(i18n, cdr) {
+        this.i18n = i18n;
+        this.cdr = cdr;
+        this.locale = {};
+        this.data = [];
+        this.loading = false;
+        this.popoverVisible = false;
+        this.centered = false;
+        this.select = new EventEmitter();
+        this.clear = new EventEmitter();
+        this.popoverVisibleChange = new EventEmitter();
+    }
+    onVisibleChange(result) {
+        this.popoverVisibleChange.emit(result);
+    }
+    onSelect(i) {
+        this.select.emit(i);
+    }
+    onClear(title) {
+        this.clear.emit(title);
+    }
+    ngOnInit() {
+        this.i18n$ = this.i18n.change.subscribe(() => {
+            this.locale = this.i18n.getData('noticeIcon');
+            this.cdr.markForCheck();
+        });
+    }
+    ngOnChanges() {
+        this.cdr.markForCheck();
+    }
+    ngOnDestroy() {
+        this.i18n$.unsubscribe();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.4", ngImport: i0, type: NoticeIconComponent, deps: [{ token: i1.DelonLocaleService }, { token: i0.ChangeDetectorRef }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "16.0.4", type: NoticeIconComponent, selector: "notice-icon", inputs: { data: "data", count: "count", loading: "loading", popoverVisible: "popoverVisible", btnClass: "btnClass", btnIconClass: "btnIconClass", centered: "centered" }, outputs: { select: "select", clear: "clear", popoverVisibleChange: "popoverVisibleChange" }, host: { properties: { "class.notice-icon__btn": "true" } }, exportAs: ["noticeIcon"], usesOnChanges: true, ngImport: i0, template: "<ng-template #badgeTpl>\n  <nz-badge [nzCount]=\"count\" [ngClass]=\"btnClass!\" [nzStyle]=\"{ 'box-shadow': 'none' }\">\n    <i nz-icon nzType=\"bell\" [ngClass]=\"btnIconClass!\"></i>\n  </nz-badge>\n</ng-template>\n<div *ngIf=\"data!.length === 0\">\n  <ng-template [ngTemplateOutlet]=\"badgeTpl\"></ng-template>\n</div>\n<div\n  *ngIf=\"data!.length > 0\"\n  nz-dropdown\n  [nzVisible]=\"popoverVisible\"\n  (nzVisibleChange)=\"onVisibleChange($event)\"\n  nzTrigger=\"click\"\n  nzPlacement=\"bottomRight\"\n  [nzOverlayClassName]=\"overlayCls\"\n  [nzDropdownMenu]=\"noticeMenu\"\n>\n  <ng-template [ngTemplateOutlet]=\"badgeTpl\"></ng-template>\n</div>\n<nz-dropdown-menu #noticeMenu=\"nzDropdownMenu\">\n  <nz-spin [nzSpinning]=\"loading\" [nzDelay]=\"0\">\n    <nz-tabset nzSelectedIndex=\"0\" [nzCentered]=\"centered\">\n      <nz-tab *ngFor=\"let i of data\" [nzTitle]=\"i.title\">\n        <notice-icon-tab\n          [locale]=\"locale\"\n          [data]=\"i\"\n          (select)=\"onSelect($event)\"\n          (clear)=\"onClear($event)\"\n        ></notice-icon-tab>\n      </nz-tab>\n    </nz-tabset>\n  </nz-spin>\n</nz-dropdown-menu>\n", dependencies: [{ kind: "directive", type: i2.NgClass, selector: "[ngClass]", inputs: ["class", "ngClass"] }, { kind: "directive", type: i2.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { kind: "directive", type: i2.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "directive", type: i2.NgTemplateOutlet, selector: "[ngTemplateOutlet]", inputs: ["ngTemplateOutletContext", "ngTemplateOutlet", "ngTemplateOutletInjector"] }, { kind: "component", type: i3.NzBadgeComponent, selector: "nz-badge", inputs: ["nzShowZero", "nzShowDot", "nzStandalone", "nzDot", "nzOverflowCount", "nzColor", "nzStyle", "nzText", "nzTitle", "nzStatus", "nzCount", "nzOffset", "nzSize"], exportAs: ["nzBadge"] }, { kind: "directive", type: i4.NzDropDownDirective, selector: "[nz-dropdown]", inputs: ["nzDropdownMenu", "nzTrigger", "nzMatchWidthElement", "nzBackdrop", "nzClickHide", "nzDisabled", "nzVisible", "nzOverlayClassName", "nzOverlayStyle", "nzPlacement"], outputs: ["nzVisibleChange"], exportAs: ["nzDropdown"] }, { kind: "component", type: i4.NzDropdownMenuComponent, selector: "nz-dropdown-menu", exportAs: ["nzDropdownMenu"] }, { kind: "directive", type: i5.NzIconDirective, selector: "[nz-icon]", inputs: ["nzSpin", "nzRotate", "nzType", "nzTheme", "nzTwotoneColor", "nzIconfont"], exportAs: ["nzIcon"] }, { kind: "component", type: i6.NzSpinComponent, selector: "nz-spin", inputs: ["nzIndicator", "nzSize", "nzTip", "nzDelay", "nzSimple", "nzSpinning"], exportAs: ["nzSpin"] }, { kind: "component", type: i7.NzTabSetComponent, selector: "nz-tabset", inputs: ["nzSelectedIndex", "nzTabPosition", "nzTabBarExtraContent", "nzCanDeactivate", "nzAddIcon", "nzTabBarStyle", "nzType", "nzSize", "nzAnimated", "nzTabBarGutter", "nzHideAdd", "nzCentered", "nzHideAll", "nzLinkRouter", "nzLinkExact"], outputs: ["nzSelectChange", "nzSelectedIndexChange", "nzTabListScroll", "nzClose", "nzAdd"], exportAs: ["nzTabset"] }, { kind: "component", type: i7.NzTabComponent, selector: "nz-tab", inputs: ["nzTitle", "nzClosable", "nzCloseIcon", "nzDisabled", "nzForceRender"], outputs: ["nzSelect", "nzDeselect", "nzClick", "nzContextmenu"], exportAs: ["nzTab"] }, { kind: "component", type: i8.NoticeIconTabComponent, selector: "notice-icon-tab", inputs: ["locale", "data"], outputs: ["select", "clear"], exportAs: ["noticeIconTab"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush, encapsulation: i0.ViewEncapsulation.None }); }
+}
+__decorate([
+    InputNumber()
+], NoticeIconComponent.prototype, "count", void 0);
+__decorate([
+    InputBoolean()
+], NoticeIconComponent.prototype, "loading", void 0);
+__decorate([
+    InputBoolean()
+], NoticeIconComponent.prototype, "popoverVisible", void 0);
+__decorate([
+    InputBoolean()
+], NoticeIconComponent.prototype, "centered", void 0);
+export { NoticeIconComponent };
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.4", ngImport: i0, type: NoticeIconComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'notice-icon', exportAs: 'noticeIcon', host: { '[class.notice-icon__btn]': 'true' }, preserveWhitespaces: false, changeDetection: ChangeDetectionStrategy.OnPush, encapsulation: ViewEncapsulation.None, template: "<ng-template #badgeTpl>\n  <nz-badge [nzCount]=\"count\" [ngClass]=\"btnClass!\" [nzStyle]=\"{ 'box-shadow': 'none' }\">\n    <i nz-icon nzType=\"bell\" [ngClass]=\"btnIconClass!\"></i>\n  </nz-badge>\n</ng-template>\n<div *ngIf=\"data!.length === 0\">\n  <ng-template [ngTemplateOutlet]=\"badgeTpl\"></ng-template>\n</div>\n<div\n  *ngIf=\"data!.length > 0\"\n  nz-dropdown\n  [nzVisible]=\"popoverVisible\"\n  (nzVisibleChange)=\"onVisibleChange($event)\"\n  nzTrigger=\"click\"\n  nzPlacement=\"bottomRight\"\n  [nzOverlayClassName]=\"overlayCls\"\n  [nzDropdownMenu]=\"noticeMenu\"\n>\n  <ng-template [ngTemplateOutlet]=\"badgeTpl\"></ng-template>\n</div>\n<nz-dropdown-menu #noticeMenu=\"nzDropdownMenu\">\n  <nz-spin [nzSpinning]=\"loading\" [nzDelay]=\"0\">\n    <nz-tabset nzSelectedIndex=\"0\" [nzCentered]=\"centered\">\n      <nz-tab *ngFor=\"let i of data\" [nzTitle]=\"i.title\">\n        <notice-icon-tab\n          [locale]=\"locale\"\n          [data]=\"i\"\n          (select)=\"onSelect($event)\"\n          (clear)=\"onClear($event)\"\n        ></notice-icon-tab>\n      </nz-tab>\n    </nz-tabset>\n  </nz-spin>\n</nz-dropdown-menu>\n" }]
+        }], ctorParameters: function () { return [{ type: i1.DelonLocaleService }, { type: i0.ChangeDetectorRef }]; }, propDecorators: { data: [{
+                type: Input
+            }], count: [{
+                type: Input
+            }], loading: [{
+                type: Input
+            }], popoverVisible: [{
+                type: Input
+            }], btnClass: [{
+                type: Input
+            }], btnIconClass: [{
+                type: Input
+            }], centered: [{
+                type: Input
+            }], select: [{
+                type: Output
+            }], clear: [{
+                type: Output
+            }], popoverVisibleChange: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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