@spartan-ng/cli 0.0.1-alpha.323

package/src/generators/ui/libs/ui-avatar-helm/files/lib/image/hlm-avatar-image.directive.spec.ts.template

@@ -0,0 +1,44 @@
+import { Component } from '@angular/core';
+import { ComponentFixture, TestBed } from '@angular/core/testing';
+import { HlmAvatarImageDirective } from './hlm-avatar-image.directive';
+
+@Component({
+	selector: 'hlm-mock',
+	standalone: true,
+	imports: [HlmAvatarImageDirective],
+	template: `
+		<img hlmAvatarImage [class]="userCls" />
+	`,
+})
+class HlmMockComponent {
+	userCls = '';
+}
+
+describe('HlmAvatarImageDirective', () => {
+	let component: HlmMockComponent;
+	let fixture: ComponentFixture<HlmMockComponent>;
+
+	beforeEach(() => {
+		fixture = TestBed.createComponent(HlmMockComponent);
+		component = fixture.componentInstance;
+	});
+
+	it('should compile', () => {
+		expect(component).toBeTruthy();
+	});
+
+	it('should add the default classes if no inputs are provided', () => {
+		fixture.detectChanges();
+		expect(fixture.nativeElement.querySelector('img').className).toBe('aspect-square h-full object-cover w-full');
+	});
+
+	it('should add any user defined classes', async () => {
+		component.userCls = 'test-class';
+		fixture.detectChanges();
+
+		// fallback uses Promise.resolve().then() so we need to wait for the next tick
+		setTimeout(() => {
+			expect(fixture.nativeElement.querySelector('img').className).toContain('test-class');
+		});
+	});
+});

package/src/generators/ui/libs/ui-avatar-helm/files/lib/image/hlm-avatar-image.directive.ts.template

@@ -0,0 +1,28 @@
+import { computed, Directive, inject, Input, signal } from '@angular/core';
+import { BrnAvatarImageDirective } from '@spartan-ng/ui-avatar-brain';
+import { hlm } from '@spartan-ng/ui-core';
+import { ClassValue } from 'clsx';
+
+@Directive({
+	selector: 'img[hlmAvatarImage]',
+	standalone: true,
+	exportAs: 'avatarImage',
+	hostDirectives: [BrnAvatarImageDirective],
+	host: {
+		'[class]': '_computedClass()',
+	},
+})
+export class HlmAvatarImageDirective {
+	canShow = inject(BrnAvatarImageDirective).canShow;
+
+	private readonly _userCls = signal<ClassValue>('');
+	@Input()
+	set class(userCls: ClassValue) {
+		this._userCls.set(userCls);
+	}
+
+	protected _computedClass = computed(() => this._generateClass());
+	private _generateClass() {
+		return hlm('aspect-square object-cover h-full w-full', this._userCls());
+	}
+}

package/src/generators/ui/libs/ui-avatar-helm/files/lib/image/index.ts.template

@@ -0,0 +1 @@
+export * from './hlm-avatar-image.directive';

package/src/generators/ui/libs/ui-avatar-helm/generator.d.ts

@@ -0,0 +1,3 @@
+import { Tree } from '@nx/devkit';
+import { HlmBaseGeneratorSchema } from '../../../base/schema';
+export declare function generator(tree: Tree, options: HlmBaseGeneratorSchema): Promise<import("@nx/devkit").GeneratorCallback>;

package/src/generators/ui/libs/ui-avatar-helm/generator.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generator = void 0;
+const tslib_1 = require("tslib");
+const generator_1 = require("../../../base/generator");
+function generator(tree, options) {
+    return tslib_1.__awaiter(this, void 0, void 0, function* () {
+        return yield (0, generator_1.default)(tree, Object.assign(Object.assign({}, options), { primitiveName: 'avatar', internalName: 'ui-avatar-helm', publicName: 'ui-avatar-helm' }));
+    });
+}
+exports.generator = generator;
+//# sourceMappingURL=generator.js.map

package/src/generators/ui/libs/ui-avatar-helm/generator.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"generator.js","sourceRoot":"","sources":["../../../../../../../../libs/cli/src/generators/ui/libs/ui-avatar-helm/generator.ts"],"names":[],"mappings":";;;;AACA,uDAAuD;AAGvD,SAAsB,SAAS,CAAC,IAAU,EAAE,OAA+B;;QAC1E,OAAO,MAAM,IAAA,mBAAgB,EAAC,IAAI,kCAC9B,OAAO,KACV,aAAa,EAAE,QAAQ,EACvB,YAAY,EAAE,gBAAgB,EAC9B,UAAU,EAAE,gBAAgB,IAC3B,CAAC;IACJ,CAAC;CAAA;AAPD,8BAOC"}

package/src/generators/ui/libs/ui-badge-helm/files/index.ts.template

@@ -0,0 +1,10 @@
+import { NgModule } from '@angular/core';
+import { HlmBadgeDirective } from './lib/hlm-badge.directive';
+
+export * from './lib/hlm-badge.directive';
+
+@NgModule({
+	imports: [HlmBadgeDirective],
+	exports: [HlmBadgeDirective],
+})
+export class HlmBadgeModule {}

package/src/generators/ui/libs/ui-badge-helm/files/lib/hlm-badge.directive.ts.template

@@ -0,0 +1,73 @@
+import { Directive, Input, booleanAttribute, computed, signal } from '@angular/core';
+import { hlm } from '@spartan-ng/ui-core';
+import { VariantProps, cva } from 'class-variance-authority';
+import { ClassValue } from 'clsx';
+
+const badgeVariants = cva(
+	'inline-flex items-center border rounded-full px-2.5 py-0.5 text-xs font-semibold transition-colors focus:outline-none focus:ring-2 focus:ring-ring focus:ring-offset-2',
+	{
+		variants: {
+			variant: {
+				default: 'bg-primary border-transparent text-primary-foreground',
+				secondary: 'bg-secondary border-transparent text-secondary-foreground',
+				destructive: 'bg-destructive border-transparent text-destructive-foreground',
+				outline: 'text-foreground border-border',
+			},
+			static: { true: '', false: '' },
+		},
+		compoundVariants: [
+			{
+				variant: 'default',
+				static: false,
+				class: 'hover:bg-primary/80',
+			},
+			{
+				variant: 'secondary',
+				static: false,
+				class: 'hover:bg-secondary/80',
+			},
+			{
+				variant: 'destructive',
+				static: false,
+				class: 'hover:bg-destructive/80',
+			},
+		],
+		defaultVariants: {
+			variant: 'default',
+			static: false,
+		},
+	},
+);
+type badgeVariants = VariantProps<typeof badgeVariants>;
+
+@Directive({
+	selector: '[hlmBadge]',
+	standalone: true,
+	host: {
+		'[class]': '_computedClass()',
+	},
+})
+export class HlmBadgeDirective {
+	private readonly _userCls = signal<ClassValue>('');
+	@Input()
+	set class(userCls: ClassValue) {
+		this._userCls.set(userCls);
+	}
+
+	private readonly _variant = signal<badgeVariants['variant']>('default');
+	@Input()
+	set variant(variant: badgeVariants['variant']) {
+		this._variant.set(variant);
+	}
+
+	private readonly _static = signal<badgeVariants['static']>(false);
+	@Input({ transform: booleanAttribute })
+	set static(value: badgeVariants['static']) {
+		this._static.set(value);
+	}
+
+	protected _computedClass = computed(() => this._generateClass());
+	private _generateClass() {
+		return hlm(badgeVariants({ variant: this._variant(), static: this._static() }), this._userCls());
+	}
+}

package/src/generators/ui/libs/ui-badge-helm/generator.d.ts

@@ -0,0 +1,3 @@
+import { Tree } from '@nx/devkit';
+import { HlmBaseGeneratorSchema } from '../../../base/schema';
+export declare function generator(tree: Tree, options: HlmBaseGeneratorSchema): Promise<import("@nx/devkit").GeneratorCallback>;

package/src/generators/ui/libs/ui-badge-helm/generator.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generator = void 0;
+const tslib_1 = require("tslib");
+const generator_1 = require("../../../base/generator");
+function generator(tree, options) {
+    return tslib_1.__awaiter(this, void 0, void 0, function* () {
+        return yield (0, generator_1.default)(tree, Object.assign(Object.assign({}, options), { primitiveName: 'badge', internalName: 'ui-badge-helm', publicName: 'ui-badge-helm' }));
+    });
+}
+exports.generator = generator;
+//# sourceMappingURL=generator.js.map

package/src/generators/ui/libs/ui-badge-helm/generator.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"generator.js","sourceRoot":"","sources":["../../../../../../../../libs/cli/src/generators/ui/libs/ui-badge-helm/generator.ts"],"names":[],"mappings":";;;;AACA,uDAAuD;AAGvD,SAAsB,SAAS,CAAC,IAAU,EAAE,OAA+B;;QAC1E,OAAO,MAAM,IAAA,mBAAgB,EAAC,IAAI,kCAC9B,OAAO,KACV,aAAa,EAAE,OAAO,EACtB,YAAY,EAAE,eAAe,EAC7B,UAAU,EAAE,eAAe,IAC1B,CAAC;IACJ,CAAC;CAAA;AAPD,8BAOC"}

package/src/generators/ui/libs/ui-button-helm/files/index.ts.template

@@ -0,0 +1,10 @@
+import { NgModule } from '@angular/core';
+import { HlmButtonDirective } from './lib/hlm-button.directive';
+
+export * from './lib/hlm-button.directive';
+
+@NgModule({
+	imports: [HlmButtonDirective],
+	exports: [HlmButtonDirective],
+})
+export class HlmButtonModule {}

package/src/generators/ui/libs/ui-button-helm/files/lib/hlm-button.directive.ts.template

@@ -0,0 +1,63 @@
+import { Directive, Input, computed, signal } from '@angular/core';
+import { hlm } from '@spartan-ng/ui-core';
+import { VariantProps, cva } from 'class-variance-authority';
+import { ClassValue } from 'clsx';
+
+const buttonVariants = cva(
+	'inline-flex items-center justify-center rounded-md text-sm font-medium transition-colors focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring focus-visible:ring-offset-2 disabled:opacity-50 disabled:pointer-events-none ring-offset-background',
+	{
+		variants: {
+			variant: {
+				default: 'bg-primary text-primary-foreground hover:bg-primary/90',
+				destructive: 'bg-destructive text-destructive-foreground hover:bg-destructive/90',
+				outline: 'border border-input hover:bg-accent hover:text-accent-foreground',
+				secondary: 'bg-secondary text-secondary-foreground hover:bg-secondary/80',
+				ghost: 'hover:bg-accent hover:text-accent-foreground',
+				link: 'underline-offset-4 hover:underline text-primary',
+			},
+			size: {
+				default: 'h-10 py-2 px-4',
+				sm: 'h-9 px-3 rounded-md',
+				lg: 'h-11 px-8 rounded-md',
+				icon: 'h-10 w-10',
+			},
+		},
+		defaultVariants: {
+			variant: 'default',
+			size: 'default',
+		},
+	},
+);
+type ButtonVariants = VariantProps<typeof buttonVariants>;
+
+@Directive({
+	selector: '[hlmBtn]',
+	standalone: true,
+	host: {
+		'[class]': '_computedClass()',
+	},
+})
+export class HlmButtonDirective {
+	private readonly _userCls = signal<ClassValue>('');
+	@Input()
+	set class(userCls: ClassValue) {
+		this._userCls.set(userCls);
+	}
+
+	private readonly _variant = signal<ButtonVariants['variant']>('default');
+	@Input()
+	set variant(variant: ButtonVariants['variant']) {
+		this._variant.set(variant);
+	}
+
+	private readonly _size = signal<ButtonVariants['size']>('default');
+	@Input()
+	set size(size: ButtonVariants['size']) {
+		this._size.set(size);
+	}
+
+	protected _computedClass = computed(() => this._generateClass());
+	private _generateClass() {
+		return hlm(buttonVariants({ variant: this._variant(), size: this._size() }), this._userCls());
+	}
+}

package/src/generators/ui/libs/ui-button-helm/generator.d.ts

@@ -0,0 +1,3 @@
+import { Tree } from '@nx/devkit';
+import { HlmBaseGeneratorSchema } from '../../../base/schema';
+export declare function generator(tree: Tree, options: HlmBaseGeneratorSchema): Promise<import("@nx/devkit").GeneratorCallback>;

package/src/generators/ui/libs/ui-button-helm/generator.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generator = void 0;
+const tslib_1 = require("tslib");
+const generator_1 = require("../../../base/generator");
+function generator(tree, options) {
+    return tslib_1.__awaiter(this, void 0, void 0, function* () {
+        return yield (0, generator_1.default)(tree, Object.assign(Object.assign({}, options), { primitiveName: 'button', internalName: 'ui-button-helm', publicName: 'ui-button-helm' }));
+    });
+}
+exports.generator = generator;
+//# sourceMappingURL=generator.js.map

package/src/generators/ui/libs/ui-button-helm/generator.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"generator.js","sourceRoot":"","sources":["../../../../../../../../libs/cli/src/generators/ui/libs/ui-button-helm/generator.ts"],"names":[],"mappings":";;;;AACA,uDAAuD;AAGvD,SAAsB,SAAS,CAAC,IAAU,EAAE,OAA+B;;QAC1E,OAAO,MAAM,IAAA,mBAAgB,EAAC,IAAI,kCAC9B,OAAO,KACV,aAAa,EAAE,QAAQ,EACvB,YAAY,EAAE,gBAAgB,EAC9B,UAAU,EAAE,gBAAgB,IAC3B,CAAC;IACJ,CAAC;CAAA;AAPD,8BAOC"}

package/src/generators/ui/libs/ui-card-helm/files/index.ts.template

@@ -0,0 +1,30 @@
+import { NgModule } from '@angular/core';
+
+import { HlmCardContentDirective } from './lib/hlm-card-content.directive';
+import { HlmCardDescriptionDirective } from './lib/hlm-card-description.directive';
+import { HlmCardFooterDirective } from './lib/hlm-card-footer.directive';
+import { HlmCardHeaderDirective } from './lib/hlm-card-header.directive';
+import { HlmCardTitleDirective } from './lib/hlm-card-title.directive';
+import { HlmCardDirective } from './lib/hlm-card.directive';
+
+export * from './lib/hlm-card-content.directive';
+export * from './lib/hlm-card-description.directive';
+export * from './lib/hlm-card-footer.directive';
+export * from './lib/hlm-card-header.directive';
+export * from './lib/hlm-card-title.directive';
+export * from './lib/hlm-card.directive';
+
+export const HlmCardImports = [
+	HlmCardDirective,
+	HlmCardHeaderDirective,
+	HlmCardFooterDirective,
+	HlmCardTitleDirective,
+	HlmCardDescriptionDirective,
+	HlmCardContentDirective,
+] as const;
+
+@NgModule({
+	imports: [...HlmCardImports],
+	exports: [...HlmCardImports],
+})
+export class HlmCardModule {}

package/src/generators/ui/libs/ui-card-helm/files/lib/hlm-card-content.directive.ts.template

@@ -0,0 +1,30 @@
+import { Directive, Input, computed, signal } from '@angular/core';
+import { hlm } from '@spartan-ng/ui-core';
+import { VariantProps, cva } from 'class-variance-authority';
+import { ClassValue } from 'clsx';
+
+const cardContentVariants = cva('p-6 pt-0', {
+	variants: {},
+	defaultVariants: {},
+});
+export type CardContentVariants = VariantProps<typeof cardContentVariants>;
+
+@Directive({
+	selector: '[hlmCardContent]',
+	standalone: true,
+	host: {
+		'[class]': '_computedClass()',
+	},
+})
+export class HlmCardContentDirective {
+	private readonly _userCls = signal<ClassValue>('');
+	@Input()
+	set class(userCls: ClassValue) {
+		this._userCls.set(userCls);
+	}
+
+	protected _computedClass = computed(() => this._generateClass());
+	private _generateClass() {
+		return hlm(cardContentVariants(), this._userCls());
+	}
+}

package/src/generators/ui/libs/ui-card-helm/files/lib/hlm-card-description.directive.ts.template

@@ -0,0 +1,30 @@
+import { Directive, Input, computed, signal } from '@angular/core';
+import { hlm } from '@spartan-ng/ui-core';
+import { VariantProps, cva } from 'class-variance-authority';
+import { ClassValue } from 'clsx';
+
+const cardDescriptionVariants = cva('text-sm text-muted-foreground', {
+	variants: {},
+	defaultVariants: {},
+});
+export type CardDescriptionVariants = VariantProps<typeof cardDescriptionVariants>;
+
+@Directive({
+	selector: '[hlmCardDescription]',
+	standalone: true,
+	host: {
+		'[class]': '_computedClass()',
+	},
+})
+export class HlmCardDescriptionDirective {
+	private readonly _userCls = signal<ClassValue>('');
+	@Input()
+	set class(userCls: ClassValue) {
+		this._userCls.set(userCls);
+	}
+
+	protected _computedClass = computed(() => this._generateClass());
+	private _generateClass() {
+		return hlm(cardDescriptionVariants(), this._userCls());
+	}
+}

package/src/generators/ui/libs/ui-card-helm/files/lib/hlm-card-footer.directive.ts.template

@@ -0,0 +1,43 @@
+import { Directive, Input, computed, signal } from '@angular/core';
+import { hlm } from '@spartan-ng/ui-core';
+import { VariantProps, cva } from 'class-variance-authority';
+import { ClassValue } from 'clsx';
+
+const cardFooterVariants = cva('flex p-6 pt-0', {
+	variants: {
+		direction: {
+			row: 'flex-row items-center space-x-1.5',
+			column: 'flex-col space-y-1.5',
+		},
+	},
+	defaultVariants: {
+		direction: 'row',
+	},
+});
+export type CardFooterVariants = VariantProps<typeof cardFooterVariants>;
+
+@Directive({
+	selector: '[hlmCardFooter]',
+	standalone: true,
+	host: {
+		'[class]': '_computedClass()',
+	},
+})
+export class HlmCardFooterDirective {
+	private readonly _userCls = signal<ClassValue>('');
+	@Input()
+	set class(userCls: ClassValue) {
+		this._userCls.set(userCls);
+	}
+
+	private readonly _direction = signal<CardFooterVariants['direction']>('row');
+	@Input()
+	set direction(direction: CardFooterVariants['direction']) {
+		this._direction.set(direction);
+	}
+
+	protected _computedClass = computed(() => this._generateClass());
+	private _generateClass() {
+		return hlm(cardFooterVariants({ direction: this._direction() }), this._userCls());
+	}
+}

package/src/generators/ui/libs/ui-card-helm/files/lib/hlm-card-header.directive.ts.template

@@ -0,0 +1,43 @@
+import { Directive, Input, computed, signal } from '@angular/core';
+import { hlm } from '@spartan-ng/ui-core';
+import { VariantProps, cva } from 'class-variance-authority';
+import { ClassValue } from 'clsx';
+
+const cardHeaderVariants = cva('flex p-6', {
+	variants: {
+		direction: {
+			row: 'flex-row items-center space-x-1.5',
+			column: 'flex-col space-y-1.5',
+		},
+	},
+	defaultVariants: {
+		direction: 'column',
+	},
+});
+export type CardHeaderVariants = VariantProps<typeof cardHeaderVariants>;
+
+@Directive({
+	selector: '[hlmCardHeader]',
+	standalone: true,
+	host: {
+		'[class]': '_computedClass()',
+	},
+})
+export class HlmCardHeaderDirective {
+	private readonly _userCls = signal<ClassValue>('');
+	@Input()
+	set class(userCls: ClassValue) {
+		this._userCls.set(userCls);
+	}
+
+	private readonly _direction = signal<CardHeaderVariants['direction']>('column');
+	@Input()
+	set direction(direction: CardHeaderVariants['direction']) {
+		this._direction.set(direction);
+	}
+
+	protected _computedClass = computed(() => this._generateClass());
+	private _generateClass() {
+		return hlm(cardHeaderVariants({ direction: this._direction() }), this._userCls());
+	}
+}

package/src/generators/ui/libs/ui-card-helm/files/lib/hlm-card-title.directive.ts.template

@@ -0,0 +1,30 @@
+import { Directive, Input, computed, signal } from '@angular/core';
+import { hlm } from '@spartan-ng/ui-core';
+import { VariantProps, cva } from 'class-variance-authority';
+import { ClassValue } from 'clsx';
+
+const cardTitleVariants = cva('text-lg font-semibold leading-none tracking-tight', {
+	variants: {},
+	defaultVariants: {},
+});
+export type CardTitleVariants = VariantProps<typeof cardTitleVariants>;
+
+@Directive({
+	selector: '[hlmCardTitle]',
+	standalone: true,
+	host: {
+		'[class]': '_computedClass()',
+	},
+})
+export class HlmCardTitleDirective {
+	private readonly _userCls = signal<ClassValue>('');
+	@Input()
+	set class(userCls: ClassValue) {
+		this._userCls.set(userCls);
+	}
+
+	protected _computedClass = computed(() => this._generateClass());
+	private _generateClass() {
+		return hlm(cardTitleVariants(), this._userCls());
+	}
+}

package/src/generators/ui/libs/ui-card-helm/files/lib/hlm-card.directive.ts.template

@@ -0,0 +1,33 @@
+import { Directive, Input, computed, signal } from '@angular/core';
+import { hlm } from '@spartan-ng/ui-core';
+import { VariantProps, cva } from 'class-variance-authority';
+import { ClassValue } from 'clsx';
+
+const cardVariants = cva(
+	'rounded-lg border border-border bg-card focus:outline-none focus:ring-2 focus:ring-ring focus:ring-offset-2 text-card-foreground shadow-sm',
+	{
+		variants: {},
+		defaultVariants: {},
+	},
+);
+export type CardVariants = VariantProps<typeof cardVariants>;
+
+@Directive({
+	selector: '[hlmCard]',
+	standalone: true,
+	host: {
+		'[class]': '_computedClass()',
+	},
+})
+export class HlmCardDirective {
+	private readonly _userCls = signal<ClassValue>('');
+	@Input()
+	set class(userCls: ClassValue) {
+		this._userCls.set(userCls);
+	}
+
+	protected _computedClass = computed(() => this._generateClass());
+	private _generateClass() {
+		return hlm(cardVariants(), this._userCls());
+	}
+}

package/src/generators/ui/libs/ui-card-helm/generator.d.ts

@@ -0,0 +1,3 @@
+import { Tree } from '@nx/devkit';
+import { HlmBaseGeneratorSchema } from '../../../base/schema';
+export declare function generator(tree: Tree, options: HlmBaseGeneratorSchema): Promise<import("@nx/devkit").GeneratorCallback>;

package/src/generators/ui/libs/ui-card-helm/generator.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generator = void 0;
+const tslib_1 = require("tslib");
+const generator_1 = require("../../../base/generator");
+function generator(tree, options) {
+    return tslib_1.__awaiter(this, void 0, void 0, function* () {
+        return yield (0, generator_1.default)(tree, Object.assign(Object.assign({}, options), { primitiveName: 'card', internalName: 'ui-card-helm', publicName: 'ui-card-helm' }));
+    });
+}
+exports.generator = generator;
+//# sourceMappingURL=generator.js.map

package/src/generators/ui/libs/ui-card-helm/generator.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"generator.js","sourceRoot":"","sources":["../../../../../../../../libs/cli/src/generators/ui/libs/ui-card-helm/generator.ts"],"names":[],"mappings":";;;;AACA,uDAAuD;AAGvD,SAAsB,SAAS,CAAC,IAAU,EAAE,OAA+B;;QAC1E,OAAO,MAAM,IAAA,mBAAgB,EAAC,IAAI,kCAC9B,OAAO,KACV,aAAa,EAAE,MAAM,EACrB,YAAY,EAAE,cAAc,EAC5B,UAAU,EAAE,cAAc,IACzB,CAAC;IACJ,CAAC;CAAA;AAPD,8BAOC"}

package/src/generators/ui/libs/ui-command-helm/files/index.ts.template

@@ -0,0 +1,49 @@
+import { NgModule } from '@angular/core';
+
+import { HlmCommandDialogCloseButtonDirective } from './lib/hlm-command-dialog-close-button.directive';
+import { HlmCommandDialogDirective } from './lib/hlm-command-dialog.directive';
+import { HlmCommandEmptyDirective } from './lib/hlm-command-empty.directive';
+import { HlmCommandGroupDirective } from './lib/hlm-command-group.directive';
+import { HlmCommandInputWrapperComponent } from './lib/hlm-command-input-wrapper.component';
+import { HlmCommandInputDirective } from './lib/hlm-command-input.directive';
+import { HlmCommandItemIconDirective } from './lib/hlm-command-item-icon.directive';
+import { HlmCommandItemDirective } from './lib/hlm-command-item.directive';
+import { HlmCommandListDirective } from './lib/hlm-command-list.directive';
+import { HlmCommandSeparatorDirective } from './lib/hlm-command-separator.directive';
+import { HlmCommandShortcutComponent } from './lib/hlm-command-shortcut.component';
+import { HlmCommandDirective } from './lib/hlm-command.directive';
+
+export * from './lib/hlm-command-dialog-close-button.directive';
+export * from './lib/hlm-command-dialog.directive';
+export * from './lib/hlm-command-empty.directive';
+export * from './lib/hlm-command-group.directive';
+export * from './lib/hlm-command-input-wrapper.component';
+export * from './lib/hlm-command-input.directive';
+export * from './lib/hlm-command-item-icon.directive';
+export * from './lib/hlm-command-item.directive';
+export * from './lib/hlm-command-list.directive';
+export * from './lib/hlm-command-loader.directive';
+export * from './lib/hlm-command-separator.directive';
+export * from './lib/hlm-command-shortcut.component';
+export * from './lib/hlm-command.directive';
+
+export const HlmCommandImports = [
+	HlmCommandDirective,
+	HlmCommandInputDirective,
+	HlmCommandItemDirective,
+	HlmCommandSeparatorDirective,
+	HlmCommandGroupDirective,
+	HlmCommandListDirective,
+	HlmCommandShortcutComponent,
+	HlmCommandItemIconDirective,
+	HlmCommandEmptyDirective,
+	HlmCommandInputWrapperComponent,
+	HlmCommandDialogCloseButtonDirective,
+	HlmCommandDialogDirective,
+] as const;
+
+@NgModule({
+	imports: [...HlmCommandImports],
+	exports: [...HlmCommandImports],
+})
+export class HlmCommandModule {}

package/src/generators/ui/libs/ui-command-helm/files/lib/hlm-command-dialog-close-button.directive.ts.template

@@ -0,0 +1,30 @@
+import { computed, Directive, inject, Input, signal } from '@angular/core';
+import { HlmButtonDirective } from '@spartan-ng/ui-button-helm';
+import { hlm } from '@spartan-ng/ui-core';
+import { ClassValue } from 'clsx';
+
+@Directive({
+	selector: '[hlmCmdDialogCloseBtn]',
+	standalone: true,
+	hostDirectives: [HlmButtonDirective],
+	host: {
+		'[class]': '_computedClass()',
+	},
+})
+export class HlmCommandDialogCloseButtonDirective {
+	private _hlmBtn = inject(HlmButtonDirective, { host: true });
+	constructor() {
+		this._hlmBtn.variant = 'ghost';
+	}
+
+	private readonly _userCls = signal<ClassValue>('');
+	@Input()
+	set class(userCls: ClassValue) {
+		this._userCls.set(userCls);
+	}
+
+	protected _computedClass = computed(() => this._generateClass());
+	private _generateClass() {
+		return hlm('!p-1 !h-5 !w-5', this._userCls());
+	}
+}