import { Directive, Input } from '@angular/core';
import { alreadyHasAThemeSuffix, getNameAndNamespace, isIconDefinition, warn, withSuffix } from '../utils';
import * as i0 from "@angular/core";
import * as i1 from "./icon.service";
function checkMeta(prev, after) {
    return prev.type === after.type && prev.theme === after.theme && prev.twoToneColor === after.twoToneColor;
}
class IconDirective {
    constructor(_iconService, _elementRef, _renderer) {
        this._iconService = _iconService;
        this._elementRef = _elementRef;
        this._renderer = _renderer;
    }
    ngOnChanges(changes) {
        if (changes.type || changes.theme || changes.twoToneColor) {
            this._changeIcon();
        }
    }
    /**
     * Render a new icon in the current element. Remove the icon when `type` is falsy.
     */
    _changeIcon() {
        return new Promise(resolve => {
            if (!this.type) {
                this._clearSVGElement();
                resolve(null);
                return;
            }
            const beforeMeta = this._getSelfRenderMeta();
            this._iconService.getRenderedContent(this._parseIconType(this.type, this.theme), this.twoToneColor).subscribe(svg => {
                // avoid race condition
                // see https://github.com/ant-design/ant-design-icons/issues/315
                const afterMeta = this._getSelfRenderMeta();
                if (checkMeta(beforeMeta, afterMeta)) {
                    this._setSVGElement(svg);
                    resolve(svg);
                }
                else {
                    resolve(null);
                }
            });
        });
    }
    _getSelfRenderMeta() {
        return {
            type: this.type,
            theme: this.theme,
            twoToneColor: this.twoToneColor
        };
    }
    /**
     * Parse a icon to the standard form, an `IconDefinition` or a string like 'account-book-fill` (with a theme suffixed).
     * If namespace is specified, ignore theme because it meaningless for users' icons.
     *
     * @param type
     * @param theme
     */
    _parseIconType(type, theme) {
        if (isIconDefinition(type)) {
            return type;
        }
        else {
            const [name, namespace] = getNameAndNamespace(type);
            if (namespace) {
                return type;
            }
            if (alreadyHasAThemeSuffix(name)) {
                if (!!theme) {
                    warn(`'type' ${name} already gets a theme inside so 'theme' ${theme} would be ignored`);
                }
                return name;
            }
            else {
                return withSuffix(name, theme || this._iconService.defaultTheme);
            }
        }
    }
    _setSVGElement(svg) {
        this._clearSVGElement();
        this._renderer.appendChild(this._elementRef.nativeElement, svg);
    }
    _clearSVGElement() {
        const el = this._elementRef.nativeElement;
        const children = el.childNodes;
        const length = children.length;
        for (let i = length - 1; i >= 0; i--) {
            const child = children[i];
            if (child.tagName?.toLowerCase() === 'svg') {
                this._renderer.removeChild(el, child);
            }
        }
    }
    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "16.0.2", ngImport: i0, type: IconDirective, deps: [{ token: i1.IconService }, { token: i0.ElementRef }, { token: i0.Renderer2 }], target: i0.ɵɵFactoryTarget.Directive }); }
    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "16.0.2", type: IconDirective, selector: "[antIcon]", inputs: { type: "type", theme: "theme", twoToneColor: "twoToneColor" }, usesOnChanges: true, ngImport: i0 }); }
}
export { IconDirective };
i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "16.0.2", ngImport: i0, type: IconDirective, decorators: [{
            type: Directive,
            args: [{
                    selector: '[antIcon]'
                }]
        }], ctorParameters: function () { return [{ type: i1.IconService }, { type: i0.ElementRef }, { type: i0.Renderer2 }]; }, propDecorators: { type: [{
                type: Input
            }], theme: [{
                type: Input
            }], twoToneColor: [{
                type: Input
            }] } });
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"icon.directive.js","sourceRoot":"","sources":["../../../../src/component/icon.directive.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  Directive,\n  ElementRef,\n  Input,\n  OnChanges,\n  Renderer2,\n  SimpleChanges\n} from '@angular/core';\nimport { IconDefinition, ThemeType } from '../types';\nimport { alreadyHasAThemeSuffix, getNameAndNamespace, isIconDefinition, warn, withSuffix } from '../utils';\nimport { IconService } from './icon.service';\n\ninterface RenderMeta {\n  type: string | IconDefinition;\n  theme?: ThemeType;\n  twoToneColor?: string;\n}\n\nfunction checkMeta(prev: RenderMeta, after: RenderMeta): boolean {\n  return prev.type === after.type && prev.theme === after.theme && prev.twoToneColor === after.twoToneColor;\n}\n\n@Directive({\n  selector: '[antIcon]'\n})\nexport class IconDirective implements OnChanges {\n  @Input() type: string | IconDefinition;\n\n  @Input() theme?: ThemeType;\n  @Input() twoToneColor?: string;\n\n  constructor(protected _iconService: IconService, protected _elementRef: ElementRef, protected _renderer: Renderer2) {}\n\n  ngOnChanges(changes: SimpleChanges): void {\n    if (changes.type || changes.theme || changes.twoToneColor) {\n      this._changeIcon();\n    }\n  }\n\n  /**\n   * Render a new icon in the current element. Remove the icon when `type` is falsy.\n   */\n  protected _changeIcon(): Promise<SVGElement | null> {\n    return new Promise<SVGElement | null>(resolve => {\n      if (!this.type) {\n        this._clearSVGElement();\n        resolve(null);\n        return;\n      } \n\n      const beforeMeta = this._getSelfRenderMeta();\n      this._iconService.getRenderedContent(\n        this._parseIconType(this.type, this.theme),\n        this.twoToneColor\n      ).subscribe(svg => {\n        // avoid race condition\n        // see https://github.com/ant-design/ant-design-icons/issues/315\n        const afterMeta = this._getSelfRenderMeta()\n        if (checkMeta(beforeMeta, afterMeta)) {\n          this._setSVGElement(svg);\n          resolve(svg);\n        } else {\n          resolve(null);\n        }\n      });\n    });\n  }\n\n  protected _getSelfRenderMeta(): RenderMeta {\n    return {\n      type: this.type,\n      theme: this.theme,\n      twoToneColor: this.twoToneColor\n    };\n  }\n\n  /**\n   * Parse a icon to the standard form, an `IconDefinition` or a string like 'account-book-fill` (with a theme suffixed).\n   * If namespace is specified, ignore theme because it meaningless for users' icons.\n   *\n   * @param type\n   * @param theme\n   */\n  protected _parseIconType(type: string | IconDefinition, theme?: ThemeType): IconDefinition | string {\n    if (isIconDefinition(type)) {\n      return type;\n    } else {\n      const [ name, namespace ] = getNameAndNamespace(type);\n      if (namespace) {\n        return type;\n      }\n      if (alreadyHasAThemeSuffix(name)) {\n        if (!!theme) {\n          warn(`'type' ${name} already gets a theme inside so 'theme' ${theme} would be ignored`);\n        }\n        return name;\n      } else {\n        return withSuffix(name, theme || this._iconService.defaultTheme);\n      }\n    }\n  }\n\n  protected _setSVGElement(svg: SVGElement): void {\n    this._clearSVGElement();\n    this._renderer.appendChild(this._elementRef.nativeElement, svg);\n  }\n\n  protected _clearSVGElement(): void {\n    const el: HTMLElement = this._elementRef.nativeElement;\n    const children = el.childNodes;\n    const length = children.length;\n    for (let i = length - 1; i >= 0; i--) {\n      const child = children[ i ] as any;\n      if (child.tagName?.toLowerCase() === 'svg') {\n        this._renderer.removeChild(el, child);\n      }\n    }\n  }\n}\n"]}