You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
760 lines
23 KiB
760 lines
23 KiB
import {
|
|
NzIconDirective,
|
|
NzIconModule
|
|
} from "./chunk-VWMHIMW7.js";
|
|
import {
|
|
NzConfigService,
|
|
WithConfig
|
|
} from "./chunk-ZHMJ6SNN.js";
|
|
import {
|
|
Directionality
|
|
} from "./chunk-6NZ2BEBG.js";
|
|
import {
|
|
Platform
|
|
} from "./chunk-IAC53GOD.js";
|
|
import {
|
|
InputBoolean
|
|
} from "./chunk-M5GY4FCO.js";
|
|
import {
|
|
NgIf
|
|
} from "./chunk-OSQBUYO6.js";
|
|
import {
|
|
ANIMATION_MODULE_TYPE,
|
|
CSP_NONCE,
|
|
ChangeDetectionStrategy,
|
|
ChangeDetectorRef,
|
|
Component,
|
|
ContentChild,
|
|
Directive,
|
|
ElementRef,
|
|
Inject,
|
|
InjectionToken,
|
|
Input,
|
|
NgModule,
|
|
NgZone,
|
|
Optional,
|
|
PLATFORM_ID,
|
|
Renderer2,
|
|
Subject,
|
|
ViewEncapsulation$1,
|
|
__decorate,
|
|
filter,
|
|
fromEvent,
|
|
makeEnvironmentProviders,
|
|
setClassMetadata,
|
|
startWith,
|
|
takeUntil,
|
|
ɵɵNgOnChangesFeature,
|
|
ɵɵStandaloneFeature,
|
|
ɵɵattribute,
|
|
ɵɵclassProp,
|
|
ɵɵcontentQuery,
|
|
ɵɵdefineComponent,
|
|
ɵɵdefineDirective,
|
|
ɵɵdefineInjector,
|
|
ɵɵdefineNgModule,
|
|
ɵɵdirectiveInject,
|
|
ɵɵelement,
|
|
ɵɵloadQuery,
|
|
ɵɵprojection,
|
|
ɵɵprojectionDef,
|
|
ɵɵproperty,
|
|
ɵɵqueryRefresh,
|
|
ɵɵtemplate
|
|
} from "./chunk-FGESKT7O.js";
|
|
|
|
// node_modules/ng-zorro-antd/fesm2022/ng-zorro-antd-core-transition-patch.mjs
|
|
var _NzTransitionPatchDirective = class _NzTransitionPatchDirective {
|
|
setHiddenAttribute() {
|
|
if (this.hidden) {
|
|
if (typeof this.hidden === "string") {
|
|
this.renderer.setAttribute(this.elementRef.nativeElement, "hidden", this.hidden);
|
|
} else {
|
|
this.renderer.setAttribute(this.elementRef.nativeElement, "hidden", "");
|
|
}
|
|
} else {
|
|
this.renderer.removeAttribute(this.elementRef.nativeElement, "hidden");
|
|
}
|
|
}
|
|
constructor(elementRef, renderer) {
|
|
this.elementRef = elementRef;
|
|
this.renderer = renderer;
|
|
this.hidden = null;
|
|
this.renderer.setAttribute(this.elementRef.nativeElement, "hidden", "");
|
|
}
|
|
ngOnChanges() {
|
|
this.setHiddenAttribute();
|
|
}
|
|
ngAfterViewInit() {
|
|
this.setHiddenAttribute();
|
|
}
|
|
};
|
|
_NzTransitionPatchDirective.ɵfac = function NzTransitionPatchDirective_Factory(t) {
|
|
return new (t || _NzTransitionPatchDirective)(ɵɵdirectiveInject(ElementRef), ɵɵdirectiveInject(Renderer2));
|
|
};
|
|
_NzTransitionPatchDirective.ɵdir = ɵɵdefineDirective({
|
|
type: _NzTransitionPatchDirective,
|
|
selectors: [["", "nz-button", ""], ["nz-button-group"], ["", "nz-icon", ""], ["", "nz-menu-item", ""], ["", "nz-submenu", ""], ["nz-select-top-control"], ["nz-select-placeholder"], ["nz-input-group"]],
|
|
inputs: {
|
|
hidden: "hidden"
|
|
},
|
|
standalone: true,
|
|
features: [ɵɵNgOnChangesFeature]
|
|
});
|
|
var NzTransitionPatchDirective = _NzTransitionPatchDirective;
|
|
(() => {
|
|
(typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(NzTransitionPatchDirective, [{
|
|
type: Directive,
|
|
args: [{
|
|
selector: "[nz-button], nz-button-group, [nz-icon], [nz-menu-item], [nz-submenu], nz-select-top-control, nz-select-placeholder, nz-input-group",
|
|
standalone: true
|
|
}]
|
|
}], () => [{
|
|
type: ElementRef
|
|
}, {
|
|
type: Renderer2
|
|
}], {
|
|
hidden: [{
|
|
type: Input
|
|
}]
|
|
});
|
|
})();
|
|
var _NzTransitionPatchModule = class _NzTransitionPatchModule {
|
|
};
|
|
_NzTransitionPatchModule.ɵfac = function NzTransitionPatchModule_Factory(t) {
|
|
return new (t || _NzTransitionPatchModule)();
|
|
};
|
|
_NzTransitionPatchModule.ɵmod = ɵɵdefineNgModule({
|
|
type: _NzTransitionPatchModule,
|
|
imports: [NzTransitionPatchDirective],
|
|
exports: [NzTransitionPatchDirective]
|
|
});
|
|
_NzTransitionPatchModule.ɵinj = ɵɵdefineInjector({});
|
|
var NzTransitionPatchModule = _NzTransitionPatchModule;
|
|
(() => {
|
|
(typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(NzTransitionPatchModule, [{
|
|
type: NgModule,
|
|
args: [{
|
|
imports: [NzTransitionPatchDirective],
|
|
exports: [NzTransitionPatchDirective]
|
|
}]
|
|
}], null, null);
|
|
})();
|
|
|
|
// node_modules/ng-zorro-antd/fesm2022/ng-zorro-antd-core-wave.mjs
|
|
var NzWaveRenderer = class {
|
|
get waveAttributeName() {
|
|
return this.insertExtraNode ? "ant-click-animating" : "ant-click-animating-without-extra-node";
|
|
}
|
|
constructor(triggerElement, ngZone, insertExtraNode, platformId, cspNonce) {
|
|
this.triggerElement = triggerElement;
|
|
this.ngZone = ngZone;
|
|
this.insertExtraNode = insertExtraNode;
|
|
this.platformId = platformId;
|
|
this.cspNonce = cspNonce;
|
|
this.waveTransitionDuration = 400;
|
|
this.styleForPseudo = null;
|
|
this.extraNode = null;
|
|
this.lastTime = 0;
|
|
this.onClick = (event) => {
|
|
if (!this.triggerElement || !this.triggerElement.getAttribute || this.triggerElement.getAttribute("disabled") || event.target.tagName === "INPUT" || this.triggerElement.className.indexOf("disabled") >= 0) {
|
|
return;
|
|
}
|
|
this.fadeOutWave();
|
|
};
|
|
this.platform = new Platform(this.platformId);
|
|
this.clickHandler = this.onClick.bind(this);
|
|
this.bindTriggerEvent();
|
|
}
|
|
bindTriggerEvent() {
|
|
if (this.platform.isBrowser) {
|
|
this.ngZone.runOutsideAngular(() => {
|
|
this.removeTriggerEvent();
|
|
if (this.triggerElement) {
|
|
this.triggerElement.addEventListener("click", this.clickHandler, true);
|
|
}
|
|
});
|
|
}
|
|
}
|
|
removeTriggerEvent() {
|
|
if (this.triggerElement) {
|
|
this.triggerElement.removeEventListener("click", this.clickHandler, true);
|
|
}
|
|
}
|
|
removeStyleAndExtraNode() {
|
|
if (this.styleForPseudo && document.body.contains(this.styleForPseudo)) {
|
|
document.body.removeChild(this.styleForPseudo);
|
|
this.styleForPseudo = null;
|
|
}
|
|
if (this.insertExtraNode && this.triggerElement.contains(this.extraNode)) {
|
|
this.triggerElement.removeChild(this.extraNode);
|
|
}
|
|
}
|
|
destroy() {
|
|
this.removeTriggerEvent();
|
|
this.removeStyleAndExtraNode();
|
|
}
|
|
fadeOutWave() {
|
|
const node = this.triggerElement;
|
|
const waveColor = this.getWaveColor(node);
|
|
node.setAttribute(this.waveAttributeName, "true");
|
|
if (Date.now() < this.lastTime + this.waveTransitionDuration) {
|
|
return;
|
|
}
|
|
if (this.isValidColor(waveColor)) {
|
|
if (!this.styleForPseudo) {
|
|
this.styleForPseudo = document.createElement("style");
|
|
if (this.cspNonce) {
|
|
this.styleForPseudo.nonce = this.cspNonce;
|
|
}
|
|
}
|
|
this.styleForPseudo.innerHTML = `
|
|
[ant-click-animating-without-extra-node='true']::after, .ant-click-animating-node {
|
|
--antd-wave-shadow-color: ${waveColor};
|
|
}`;
|
|
document.body.appendChild(this.styleForPseudo);
|
|
}
|
|
if (this.insertExtraNode) {
|
|
if (!this.extraNode) {
|
|
this.extraNode = document.createElement("div");
|
|
}
|
|
this.extraNode.className = "ant-click-animating-node";
|
|
node.appendChild(this.extraNode);
|
|
}
|
|
this.lastTime = Date.now();
|
|
this.runTimeoutOutsideZone(() => {
|
|
node.removeAttribute(this.waveAttributeName);
|
|
this.removeStyleAndExtraNode();
|
|
}, this.waveTransitionDuration);
|
|
}
|
|
isValidColor(color) {
|
|
return !!color && color !== "#ffffff" && color !== "rgb(255, 255, 255)" && this.isNotGrey(color) && !/rgba\(\d*, \d*, \d*, 0\)/.test(color) && color !== "transparent";
|
|
}
|
|
isNotGrey(color) {
|
|
const match = color.match(/rgba?\((\d*), (\d*), (\d*)(, [\.\d]*)?\)/);
|
|
if (match && match[1] && match[2] && match[3]) {
|
|
return !(match[1] === match[2] && match[2] === match[3]);
|
|
}
|
|
return true;
|
|
}
|
|
getWaveColor(node) {
|
|
const nodeStyle = getComputedStyle(node);
|
|
return nodeStyle.getPropertyValue("border-top-color") || // Firefox Compatible
|
|
nodeStyle.getPropertyValue("border-color") || nodeStyle.getPropertyValue("background-color");
|
|
}
|
|
runTimeoutOutsideZone(fn, delay) {
|
|
this.ngZone.runOutsideAngular(() => setTimeout(fn, delay));
|
|
}
|
|
};
|
|
var NZ_WAVE_GLOBAL_DEFAULT_CONFIG = {
|
|
disabled: false
|
|
};
|
|
var NZ_WAVE_GLOBAL_CONFIG = new InjectionToken("nz-wave-global-options");
|
|
function provideNzWave(config) {
|
|
return makeEnvironmentProviders([{
|
|
provide: NZ_WAVE_GLOBAL_CONFIG,
|
|
useValue: config
|
|
}]);
|
|
}
|
|
var _NzWaveDirective = class _NzWaveDirective {
|
|
get disabled() {
|
|
return this.waveDisabled;
|
|
}
|
|
get rendererRef() {
|
|
return this.waveRenderer;
|
|
}
|
|
constructor(ngZone, elementRef, config, animationType, platformId, cspNonce) {
|
|
this.ngZone = ngZone;
|
|
this.elementRef = elementRef;
|
|
this.config = config;
|
|
this.animationType = animationType;
|
|
this.platformId = platformId;
|
|
this.cspNonce = cspNonce;
|
|
this.nzWaveExtraNode = false;
|
|
this.waveDisabled = false;
|
|
this.waveDisabled = this.isConfigDisabled();
|
|
}
|
|
isConfigDisabled() {
|
|
let disabled = false;
|
|
if (this.config && typeof this.config.disabled === "boolean") {
|
|
disabled = this.config.disabled;
|
|
}
|
|
if (this.animationType === "NoopAnimations") {
|
|
disabled = true;
|
|
}
|
|
return disabled;
|
|
}
|
|
ngOnDestroy() {
|
|
if (this.waveRenderer) {
|
|
this.waveRenderer.destroy();
|
|
}
|
|
}
|
|
ngOnInit() {
|
|
this.renderWaveIfEnabled();
|
|
}
|
|
renderWaveIfEnabled() {
|
|
if (!this.waveDisabled && this.elementRef.nativeElement) {
|
|
this.waveRenderer = new NzWaveRenderer(this.elementRef.nativeElement, this.ngZone, this.nzWaveExtraNode, this.platformId, this.cspNonce);
|
|
}
|
|
}
|
|
disable() {
|
|
this.waveDisabled = true;
|
|
if (this.waveRenderer) {
|
|
this.waveRenderer.removeTriggerEvent();
|
|
this.waveRenderer.removeStyleAndExtraNode();
|
|
}
|
|
}
|
|
enable() {
|
|
this.waveDisabled = this.isConfigDisabled() || false;
|
|
if (this.waveRenderer) {
|
|
this.waveRenderer.bindTriggerEvent();
|
|
}
|
|
}
|
|
};
|
|
_NzWaveDirective.ɵfac = function NzWaveDirective_Factory(t) {
|
|
return new (t || _NzWaveDirective)(ɵɵdirectiveInject(NgZone), ɵɵdirectiveInject(ElementRef), ɵɵdirectiveInject(NZ_WAVE_GLOBAL_CONFIG, 8), ɵɵdirectiveInject(ANIMATION_MODULE_TYPE, 8), ɵɵdirectiveInject(PLATFORM_ID), ɵɵdirectiveInject(CSP_NONCE, 8));
|
|
};
|
|
_NzWaveDirective.ɵdir = ɵɵdefineDirective({
|
|
type: _NzWaveDirective,
|
|
selectors: [["", "nz-wave", ""], ["button", "nz-button", "", 3, "nzType", "link", 3, "nzType", "text"]],
|
|
inputs: {
|
|
nzWaveExtraNode: "nzWaveExtraNode"
|
|
},
|
|
exportAs: ["nzWave"],
|
|
standalone: true
|
|
});
|
|
var NzWaveDirective = _NzWaveDirective;
|
|
(() => {
|
|
(typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(NzWaveDirective, [{
|
|
type: Directive,
|
|
args: [{
|
|
selector: '[nz-wave],button[nz-button]:not([nzType="link"]):not([nzType="text"])',
|
|
exportAs: "nzWave",
|
|
standalone: true
|
|
}]
|
|
}], () => [{
|
|
type: NgZone
|
|
}, {
|
|
type: ElementRef
|
|
}, {
|
|
type: void 0,
|
|
decorators: [{
|
|
type: Optional
|
|
}, {
|
|
type: Inject,
|
|
args: [NZ_WAVE_GLOBAL_CONFIG]
|
|
}]
|
|
}, {
|
|
type: void 0,
|
|
decorators: [{
|
|
type: Optional
|
|
}, {
|
|
type: Inject,
|
|
args: [ANIMATION_MODULE_TYPE]
|
|
}]
|
|
}, {
|
|
type: void 0,
|
|
decorators: [{
|
|
type: Inject,
|
|
args: [PLATFORM_ID]
|
|
}]
|
|
}, {
|
|
type: void 0,
|
|
decorators: [{
|
|
type: Optional
|
|
}, {
|
|
type: Inject,
|
|
args: [CSP_NONCE]
|
|
}]
|
|
}], {
|
|
nzWaveExtraNode: [{
|
|
type: Input
|
|
}]
|
|
});
|
|
})();
|
|
var _NzWaveModule = class _NzWaveModule {
|
|
};
|
|
_NzWaveModule.ɵfac = function NzWaveModule_Factory(t) {
|
|
return new (t || _NzWaveModule)();
|
|
};
|
|
_NzWaveModule.ɵmod = ɵɵdefineNgModule({
|
|
type: _NzWaveModule,
|
|
imports: [NzWaveDirective],
|
|
exports: [NzWaveDirective]
|
|
});
|
|
_NzWaveModule.ɵinj = ɵɵdefineInjector({
|
|
providers: [provideNzWave(NZ_WAVE_GLOBAL_DEFAULT_CONFIG)]
|
|
});
|
|
var NzWaveModule = _NzWaveModule;
|
|
(() => {
|
|
(typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(NzWaveModule, [{
|
|
type: NgModule,
|
|
args: [{
|
|
imports: [NzWaveDirective],
|
|
exports: [NzWaveDirective],
|
|
providers: [provideNzWave(NZ_WAVE_GLOBAL_DEFAULT_CONFIG)]
|
|
}]
|
|
}], null, null);
|
|
})();
|
|
|
|
// node_modules/ng-zorro-antd/fesm2022/ng-zorro-antd-button.mjs
|
|
var _c0 = ["nz-button", ""];
|
|
function NzButtonComponent_span_0_Template(rf, ctx) {
|
|
if (rf & 1) {
|
|
ɵɵelement(0, "span", 1);
|
|
}
|
|
}
|
|
var _c1 = ["*"];
|
|
var NZ_CONFIG_MODULE_NAME = "button";
|
|
var _NzButtonComponent = class _NzButtonComponent {
|
|
insertSpan(nodes, renderer) {
|
|
nodes.forEach((node) => {
|
|
if (node.nodeName === "#text") {
|
|
const span = renderer.createElement("span");
|
|
const parent = renderer.parentNode(node);
|
|
renderer.insertBefore(parent, span, node);
|
|
renderer.appendChild(span, node);
|
|
}
|
|
});
|
|
}
|
|
get iconOnly() {
|
|
const listOfNode = Array.from(this.elementRef?.nativeElement?.childNodes || []);
|
|
const noText = listOfNode.every((node) => node.nodeName !== "#text");
|
|
const noSpan = listOfNode.filter((node) => {
|
|
return !(node.nodeName === "#comment" || !!node?.attributes?.getNamedItem("nz-icon"));
|
|
}).length == 0;
|
|
const isIconOnly = !!this.nzIconDirectiveElement && noSpan && noText;
|
|
return isIconOnly;
|
|
}
|
|
constructor(ngZone, elementRef, cdr, renderer, nzConfigService, directionality) {
|
|
this.ngZone = ngZone;
|
|
this.elementRef = elementRef;
|
|
this.cdr = cdr;
|
|
this.renderer = renderer;
|
|
this.nzConfigService = nzConfigService;
|
|
this.directionality = directionality;
|
|
this._nzModuleName = NZ_CONFIG_MODULE_NAME;
|
|
this.nzBlock = false;
|
|
this.nzGhost = false;
|
|
this.nzSearch = false;
|
|
this.nzLoading = false;
|
|
this.nzDanger = false;
|
|
this.disabled = false;
|
|
this.tabIndex = null;
|
|
this.nzType = null;
|
|
this.nzShape = null;
|
|
this.nzSize = "default";
|
|
this.dir = "ltr";
|
|
this.destroy$ = new Subject();
|
|
this.loading$ = new Subject();
|
|
this.nzConfigService.getConfigChangeEventForComponent(NZ_CONFIG_MODULE_NAME).pipe(takeUntil(this.destroy$)).subscribe(() => {
|
|
this.cdr.markForCheck();
|
|
});
|
|
}
|
|
ngOnInit() {
|
|
this.directionality.change?.pipe(takeUntil(this.destroy$)).subscribe((direction) => {
|
|
this.dir = direction;
|
|
this.cdr.detectChanges();
|
|
});
|
|
this.dir = this.directionality.value;
|
|
this.ngZone.runOutsideAngular(() => {
|
|
fromEvent(this.elementRef.nativeElement, "click", {
|
|
capture: true
|
|
}).pipe(takeUntil(this.destroy$)).subscribe((event) => {
|
|
if (this.disabled && event.target?.tagName === "A" || this.nzLoading) {
|
|
event.preventDefault();
|
|
event.stopImmediatePropagation();
|
|
}
|
|
});
|
|
});
|
|
}
|
|
ngOnChanges(changes) {
|
|
const {
|
|
nzLoading
|
|
} = changes;
|
|
if (nzLoading) {
|
|
this.loading$.next(this.nzLoading);
|
|
}
|
|
}
|
|
ngAfterViewInit() {
|
|
this.insertSpan(this.elementRef.nativeElement.childNodes, this.renderer);
|
|
}
|
|
ngAfterContentInit() {
|
|
this.loading$.pipe(startWith(this.nzLoading), filter(() => !!this.nzIconDirectiveElement), takeUntil(this.destroy$)).subscribe((loading) => {
|
|
const nativeElement = this.nzIconDirectiveElement.nativeElement;
|
|
if (loading) {
|
|
this.renderer.setStyle(nativeElement, "display", "none");
|
|
} else {
|
|
this.renderer.removeStyle(nativeElement, "display");
|
|
}
|
|
});
|
|
}
|
|
ngOnDestroy() {
|
|
this.destroy$.next();
|
|
this.destroy$.complete();
|
|
}
|
|
};
|
|
_NzButtonComponent.ɵfac = function NzButtonComponent_Factory(t) {
|
|
return new (t || _NzButtonComponent)(ɵɵdirectiveInject(NgZone), ɵɵdirectiveInject(ElementRef), ɵɵdirectiveInject(ChangeDetectorRef), ɵɵdirectiveInject(Renderer2), ɵɵdirectiveInject(NzConfigService), ɵɵdirectiveInject(Directionality, 8));
|
|
};
|
|
_NzButtonComponent.ɵcmp = ɵɵdefineComponent({
|
|
type: _NzButtonComponent,
|
|
selectors: [["button", "nz-button", ""], ["a", "nz-button", ""]],
|
|
contentQueries: function NzButtonComponent_ContentQueries(rf, ctx, dirIndex) {
|
|
if (rf & 1) {
|
|
ɵɵcontentQuery(dirIndex, NzIconDirective, 5, ElementRef);
|
|
}
|
|
if (rf & 2) {
|
|
let _t;
|
|
ɵɵqueryRefresh(_t = ɵɵloadQuery()) && (ctx.nzIconDirectiveElement = _t.first);
|
|
}
|
|
},
|
|
hostAttrs: [1, "ant-btn"],
|
|
hostVars: 32,
|
|
hostBindings: function NzButtonComponent_HostBindings(rf, ctx) {
|
|
if (rf & 2) {
|
|
ɵɵattribute("tabindex", ctx.disabled ? -1 : ctx.tabIndex === null ? null : ctx.tabIndex)("disabled", ctx.disabled || null);
|
|
ɵɵclassProp("ant-btn-primary", ctx.nzType === "primary")("ant-btn-dashed", ctx.nzType === "dashed")("ant-btn-link", ctx.nzType === "link")("ant-btn-text", ctx.nzType === "text")("ant-btn-circle", ctx.nzShape === "circle")("ant-btn-round", ctx.nzShape === "round")("ant-btn-lg", ctx.nzSize === "large")("ant-btn-sm", ctx.nzSize === "small")("ant-btn-dangerous", ctx.nzDanger)("ant-btn-loading", ctx.nzLoading)("ant-btn-background-ghost", ctx.nzGhost)("ant-btn-block", ctx.nzBlock)("ant-input-search-button", ctx.nzSearch)("ant-btn-rtl", ctx.dir === "rtl")("ant-btn-icon-only", ctx.iconOnly);
|
|
}
|
|
},
|
|
inputs: {
|
|
nzBlock: "nzBlock",
|
|
nzGhost: "nzGhost",
|
|
nzSearch: "nzSearch",
|
|
nzLoading: "nzLoading",
|
|
nzDanger: "nzDanger",
|
|
disabled: "disabled",
|
|
tabIndex: "tabIndex",
|
|
nzType: "nzType",
|
|
nzShape: "nzShape",
|
|
nzSize: "nzSize"
|
|
},
|
|
exportAs: ["nzButton"],
|
|
standalone: true,
|
|
features: [ɵɵNgOnChangesFeature, ɵɵStandaloneFeature],
|
|
attrs: _c0,
|
|
ngContentSelectors: _c1,
|
|
decls: 2,
|
|
vars: 1,
|
|
consts: [["nz-icon", "", "nzType", "loading", 4, "ngIf"], ["nz-icon", "", "nzType", "loading"]],
|
|
template: function NzButtonComponent_Template(rf, ctx) {
|
|
if (rf & 1) {
|
|
ɵɵprojectionDef();
|
|
ɵɵtemplate(0, NzButtonComponent_span_0_Template, 1, 0, "span", 0);
|
|
ɵɵprojection(1);
|
|
}
|
|
if (rf & 2) {
|
|
ɵɵproperty("ngIf", ctx.nzLoading);
|
|
}
|
|
},
|
|
dependencies: [NzIconModule, NzIconDirective, NgIf],
|
|
encapsulation: 2,
|
|
changeDetection: 0
|
|
});
|
|
var NzButtonComponent = _NzButtonComponent;
|
|
__decorate([InputBoolean()], NzButtonComponent.prototype, "nzBlock", void 0);
|
|
__decorate([InputBoolean()], NzButtonComponent.prototype, "nzGhost", void 0);
|
|
__decorate([InputBoolean()], NzButtonComponent.prototype, "nzSearch", void 0);
|
|
__decorate([InputBoolean()], NzButtonComponent.prototype, "nzLoading", void 0);
|
|
__decorate([InputBoolean()], NzButtonComponent.prototype, "nzDanger", void 0);
|
|
__decorate([InputBoolean()], NzButtonComponent.prototype, "disabled", void 0);
|
|
__decorate([WithConfig()], NzButtonComponent.prototype, "nzSize", void 0);
|
|
(() => {
|
|
(typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(NzButtonComponent, [{
|
|
type: Component,
|
|
args: [{
|
|
selector: "button[nz-button], a[nz-button]",
|
|
exportAs: "nzButton",
|
|
preserveWhitespaces: false,
|
|
changeDetection: ChangeDetectionStrategy.OnPush,
|
|
encapsulation: ViewEncapsulation$1.None,
|
|
template: `
|
|
<span nz-icon nzType="loading" *ngIf="nzLoading"></span>
|
|
<ng-content></ng-content>
|
|
`,
|
|
host: {
|
|
class: "ant-btn",
|
|
"[class.ant-btn-primary]": `nzType === 'primary'`,
|
|
"[class.ant-btn-dashed]": `nzType === 'dashed'`,
|
|
"[class.ant-btn-link]": `nzType === 'link'`,
|
|
"[class.ant-btn-text]": `nzType === 'text'`,
|
|
"[class.ant-btn-circle]": `nzShape === 'circle'`,
|
|
"[class.ant-btn-round]": `nzShape === 'round'`,
|
|
"[class.ant-btn-lg]": `nzSize === 'large'`,
|
|
"[class.ant-btn-sm]": `nzSize === 'small'`,
|
|
"[class.ant-btn-dangerous]": `nzDanger`,
|
|
"[class.ant-btn-loading]": `nzLoading`,
|
|
"[class.ant-btn-background-ghost]": `nzGhost`,
|
|
"[class.ant-btn-block]": `nzBlock`,
|
|
"[class.ant-input-search-button]": `nzSearch`,
|
|
"[class.ant-btn-rtl]": `dir === 'rtl'`,
|
|
"[class.ant-btn-icon-only]": `iconOnly`,
|
|
"[attr.tabindex]": "disabled ? -1 : (tabIndex === null ? null : tabIndex)",
|
|
"[attr.disabled]": "disabled || null"
|
|
},
|
|
imports: [NzIconModule, NgIf],
|
|
standalone: true
|
|
}]
|
|
}], () => [{
|
|
type: NgZone
|
|
}, {
|
|
type: ElementRef
|
|
}, {
|
|
type: ChangeDetectorRef
|
|
}, {
|
|
type: Renderer2
|
|
}, {
|
|
type: NzConfigService
|
|
}, {
|
|
type: Directionality,
|
|
decorators: [{
|
|
type: Optional
|
|
}]
|
|
}], {
|
|
nzIconDirectiveElement: [{
|
|
type: ContentChild,
|
|
args: [NzIconDirective, {
|
|
read: ElementRef
|
|
}]
|
|
}],
|
|
nzBlock: [{
|
|
type: Input
|
|
}],
|
|
nzGhost: [{
|
|
type: Input
|
|
}],
|
|
nzSearch: [{
|
|
type: Input
|
|
}],
|
|
nzLoading: [{
|
|
type: Input
|
|
}],
|
|
nzDanger: [{
|
|
type: Input
|
|
}],
|
|
disabled: [{
|
|
type: Input
|
|
}],
|
|
tabIndex: [{
|
|
type: Input
|
|
}],
|
|
nzType: [{
|
|
type: Input
|
|
}],
|
|
nzShape: [{
|
|
type: Input
|
|
}],
|
|
nzSize: [{
|
|
type: Input
|
|
}]
|
|
});
|
|
})();
|
|
var _NzButtonGroupComponent = class _NzButtonGroupComponent {
|
|
constructor(directionality) {
|
|
this.directionality = directionality;
|
|
this.nzSize = "default";
|
|
this.dir = "ltr";
|
|
this.destroy$ = new Subject();
|
|
}
|
|
ngOnInit() {
|
|
this.dir = this.directionality.value;
|
|
this.directionality.change?.pipe(takeUntil(this.destroy$)).subscribe((direction) => {
|
|
this.dir = direction;
|
|
});
|
|
}
|
|
ngOnDestroy() {
|
|
this.destroy$.next();
|
|
this.destroy$.complete();
|
|
}
|
|
};
|
|
_NzButtonGroupComponent.ɵfac = function NzButtonGroupComponent_Factory(t) {
|
|
return new (t || _NzButtonGroupComponent)(ɵɵdirectiveInject(Directionality, 8));
|
|
};
|
|
_NzButtonGroupComponent.ɵcmp = ɵɵdefineComponent({
|
|
type: _NzButtonGroupComponent,
|
|
selectors: [["nz-button-group"]],
|
|
hostAttrs: [1, "ant-btn-group"],
|
|
hostVars: 6,
|
|
hostBindings: function NzButtonGroupComponent_HostBindings(rf, ctx) {
|
|
if (rf & 2) {
|
|
ɵɵclassProp("ant-btn-group-lg", ctx.nzSize === "large")("ant-btn-group-sm", ctx.nzSize === "small")("ant-btn-group-rtl", ctx.dir === "rtl");
|
|
}
|
|
},
|
|
inputs: {
|
|
nzSize: "nzSize"
|
|
},
|
|
exportAs: ["nzButtonGroup"],
|
|
standalone: true,
|
|
features: [ɵɵStandaloneFeature],
|
|
ngContentSelectors: _c1,
|
|
decls: 1,
|
|
vars: 0,
|
|
template: function NzButtonGroupComponent_Template(rf, ctx) {
|
|
if (rf & 1) {
|
|
ɵɵprojectionDef();
|
|
ɵɵprojection(0);
|
|
}
|
|
},
|
|
encapsulation: 2,
|
|
changeDetection: 0
|
|
});
|
|
var NzButtonGroupComponent = _NzButtonGroupComponent;
|
|
(() => {
|
|
(typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(NzButtonGroupComponent, [{
|
|
type: Component,
|
|
args: [{
|
|
selector: "nz-button-group",
|
|
exportAs: "nzButtonGroup",
|
|
changeDetection: ChangeDetectionStrategy.OnPush,
|
|
encapsulation: ViewEncapsulation$1.None,
|
|
host: {
|
|
class: "ant-btn-group",
|
|
"[class.ant-btn-group-lg]": `nzSize === 'large'`,
|
|
"[class.ant-btn-group-sm]": `nzSize === 'small'`,
|
|
"[class.ant-btn-group-rtl]": `dir === 'rtl'`
|
|
},
|
|
preserveWhitespaces: false,
|
|
template: ` <ng-content></ng-content> `,
|
|
standalone: true
|
|
}]
|
|
}], () => [{
|
|
type: Directionality,
|
|
decorators: [{
|
|
type: Optional
|
|
}]
|
|
}], {
|
|
nzSize: [{
|
|
type: Input
|
|
}]
|
|
});
|
|
})();
|
|
var _NzButtonModule = class _NzButtonModule {
|
|
};
|
|
_NzButtonModule.ɵfac = function NzButtonModule_Factory(t) {
|
|
return new (t || _NzButtonModule)();
|
|
};
|
|
_NzButtonModule.ɵmod = ɵɵdefineNgModule({
|
|
type: _NzButtonModule,
|
|
imports: [NzButtonComponent, NzButtonGroupComponent],
|
|
exports: [NzButtonComponent, NzButtonGroupComponent, NzTransitionPatchModule, NzWaveModule]
|
|
});
|
|
_NzButtonModule.ɵinj = ɵɵdefineInjector({
|
|
imports: [NzButtonComponent, NzTransitionPatchModule, NzWaveModule]
|
|
});
|
|
var NzButtonModule = _NzButtonModule;
|
|
(() => {
|
|
(typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(NzButtonModule, [{
|
|
type: NgModule,
|
|
args: [{
|
|
imports: [NzButtonComponent, NzButtonGroupComponent],
|
|
exports: [NzButtonComponent, NzButtonGroupComponent, NzTransitionPatchModule, NzWaveModule]
|
|
}]
|
|
}], null, null);
|
|
})();
|
|
|
|
export {
|
|
NzButtonComponent,
|
|
NzButtonGroupComponent,
|
|
NzButtonModule
|
|
};
|
|
//# sourceMappingURL=chunk-KMGBCF4T.js.map
|
|
|