@dynamic-field-kit/angular 1.2.4 → 1.3.3

package/dist/esm2022/components/DynamicInput.mjs

@@ -0,0 +1,191 @@
+import { CommonModule } from '@angular/common';
+import { ChangeDetectionStrategy, Component, EventEmitter, Input, Output, ViewChild, ViewContainerRef, } from '@angular/core';
+import { fieldRegistry } from '@dynamic-field-kit/core';
+import { BaseInputComponent } from './BaseInput';
+import * as i0 from "@angular/core";
+const KNOWN_PROPS = [
+    'value',
+    'label',
+    'placeholder',
+    'required',
+    'disabled',
+    'options',
+    'className',
+    'description',
+    'errorMessage',
+    'acceptFile',
+    'maxLength',
+    'minNumber',
+    'maxNumber',
+];
+export class DynamicInput extends BaseInputComponent {
+    type;
+    valueChange = new EventEmitter();
+    onChange = new EventEmitter();
+    host;
+    compRef;
+    inputInstance;
+    subscriptions = [];
+    ngOnChanges(changes) {
+        super.ngOnChanges(changes);
+        if (this.inputInstance) {
+            this.syncPropsToInstance(changes);
+        }
+        if (changes['type'] && !changes['type'].firstChange && this.host) {
+            this.render();
+        }
+        else if (!this.inputInstance && this.host) {
+            this.render();
+        }
+    }
+    ngAfterViewInit() {
+        this.render();
+    }
+    ngOnDestroy() {
+        this.cleanup();
+    }
+    syncPropsToInstance(changes) {
+        if (!this.inputInstance) {
+            return;
+        }
+        for (const prop of KNOWN_PROPS) {
+            if (changes[prop] && this.inputInstance) {
+                this.inputInstance[prop] = this[prop];
+            }
+        }
+        this.compRef?.changeDetectorRef?.detectChanges();
+    }
+    cleanup() {
+        this.cleanupSubscriptions();
+        this.cleanupRenderedComponent();
+    }
+    cleanupSubscriptions() {
+        this.subscriptions.forEach((s) => s.unsubscribe());
+        this.subscriptions = [];
+    }
+    cleanupRenderedComponent() {
+        this.compRef?.destroy();
+        this.compRef = undefined;
+        this.inputInstance = undefined;
+    }
+    render() {
+        const Renderer = fieldRegistry.get(this.type);
+        this.cleanup();
+        this.host.clear();
+        if (!Renderer) {
+            this.renderError(`Unknown field type: ${this.type}`);
+            return;
+        }
+        if (this.isComponentType(Renderer)) {
+            this.renderComponent(Renderer);
+        }
+        else if (typeof Renderer === 'function') {
+            this.renderFallback(Renderer);
+        }
+        else {
+            this.renderError(`Invalid renderer for type: ${this.type}`);
+        }
+    }
+    isComponentType(renderer) {
+        return (typeof renderer === 'object' && renderer !== null && 'cmp' in renderer);
+    }
+    renderComponent(compType) {
+        try {
+            const compRef = this.host.createComponent(compType);
+            const instance = compRef.instance;
+            if (!instance) {
+                this.renderError(`Failed to create instance for ${this.type}`);
+                return;
+            }
+            this.applyProps(instance);
+            this.bindOutputs(instance);
+            this.compRef = compRef;
+            this.inputInstance = instance;
+            compRef.changeDetectorRef.detectChanges();
+        }
+        catch {
+            this.renderError(`Failed to render field: ${this.type}`);
+        }
+    }
+    renderFallback(renderer) {
+        try {
+            const props = this.getFallbackProps();
+            const result = renderer(props);
+            if (typeof result === 'string') {
+                const el = document.createElement('div');
+                el.innerHTML = result;
+                this.host.element.nativeElement.appendChild(el);
+            }
+        }
+        catch {
+            this.renderError(`Failed to render field: ${this.type}`);
+        }
+    }
+    getFallbackProps() {
+        return {
+            value: this.value,
+            onValueChange: (v) => this.emitValue(v),
+            label: this.label ?? '',
+            placeholder: this.placeholder ?? '',
+            required: this.required ?? false,
+            options: this.options ?? [],
+            className: this.className ?? '',
+            description: this.description ?? '',
+            disabled: this.disabled ?? false,
+            errorMessage: this.errorMessage ?? '',
+        };
+    }
+    applyProps(instance) {
+        const instanceObj = instance;
+        for (const prop of KNOWN_PROPS) {
+            if (prop in this && prop in instanceObj) {
+                instanceObj[prop] = this[prop];
+            }
+        }
+    }
+    bindOutputs(instance) {
+        const outputNames = [
+            'valueChange',
+            'onValueChange',
+        ];
+        for (const outputName of outputNames) {
+            const output = instance[outputName];
+            if (output && typeof output === 'object' && 'subscribe' in output) {
+                const sub = output.subscribe((value) => this.emitValue(value));
+                this.subscriptions.push(sub);
+            }
+        }
+    }
+    emitValue(value) {
+        this.valueChange.emit(value);
+        this.onChange.emit(value);
+    }
+    renderError(message) {
+        const el = document.createElement('div');
+        el.textContent = message;
+        el.style.color = 'red';
+        this.host.element.nativeElement.appendChild(el);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.20", ngImport: i0, type: DynamicInput, deps: null, target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "19.2.20", type: DynamicInput, isStandalone: true, selector: "dfk-dynamic-input", inputs: { type: "type" }, outputs: { valueChange: "valueChange", onChange: "onChange" }, viewQueries: [{ propertyName: "host", first: true, predicate: ["host"], descendants: true, read: ViewContainerRef }], usesInheritance: true, usesOnChanges: true, ngImport: i0, template: `<div #host style="display: contents;"></div>`, isInline: true, dependencies: [{ kind: "ngmodule", type: CommonModule }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.20", ngImport: i0, type: DynamicInput, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'dfk-dynamic-input',
+                    standalone: true,
+                    imports: [CommonModule],
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: `<div #host style="display: contents;"></div>`,
+                }]
+        }], propDecorators: { type: [{
+                type: Input
+            }], valueChange: [{
+                type: Output
+            }], onChange: [{
+                type: Output
+            }], host: [{
+                type: ViewChild,
+                args: ['host', { read: ViewContainerRef, static: false }]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"DynamicInput.js","sourceRoot":"","sources":["../../../src/components/DynamicInput.ts"],"names":[],"mappings":"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","sourcesContent":["import { CommonModule } from '@angular/common';\nimport {\n  AfterViewInit,\n  ChangeDetectionStrategy,\n  Component,\n  ComponentRef,\n  EventEmitter,\n  Input,\n  OnChanges,\n  OnDestroy,\n  Output,\n  SimpleChanges,\n  Type,\n  ViewChild,\n  ViewContainerRef,\n} from '@angular/core';\nimport { fieldRegistry, FieldTypeKey } from '@dynamic-field-kit/core';\nimport { Subscription } from 'rxjs';\nimport { BaseInputComponent } from './BaseInput';\n\nconst KNOWN_PROPS = [\n  'value',\n  'label',\n  'placeholder',\n  'required',\n  'disabled',\n  'options',\n  'className',\n  'description',\n  'errorMessage',\n  'acceptFile',\n  'maxLength',\n  'minNumber',\n  'maxNumber',\n] as const;\n\n@Component({\n  selector: 'dfk-dynamic-input',\n  standalone: true,\n  imports: [CommonModule],\n  changeDetection: ChangeDetectionStrategy.OnPush,\n  template: `<div #host style=\"display: contents;\"></div>`,\n})\nexport class DynamicInput\n  extends BaseInputComponent\n  implements OnChanges, AfterViewInit, OnDestroy\n{\n  @Input() type!: FieldTypeKey;\n  @Output() override valueChange = new EventEmitter<unknown>();\n  @Output() onChange = new EventEmitter<unknown>();\n\n  @ViewChild('host', { read: ViewContainerRef, static: false })\n  host!: ViewContainerRef;\n  private compRef?: ComponentRef<unknown>;\n  private inputInstance?: unknown;\n  private subscriptions: Subscription[] = [];\n\n  ngOnChanges(changes: SimpleChanges): void {\n    super.ngOnChanges(changes);\n\n    if (this.inputInstance) {\n      this.syncPropsToInstance(changes);\n    }\n\n    if (changes['type'] && !changes['type'].firstChange && this.host) {\n      this.render();\n    } else if (!this.inputInstance && this.host) {\n      this.render();\n    }\n  }\n\n  ngAfterViewInit(): void {\n    this.render();\n  }\n\n  ngOnDestroy(): void {\n    this.cleanup();\n  }\n\n  private syncPropsToInstance(changes: SimpleChanges): void {\n    if (!this.inputInstance) {\n      return;\n    }\n\n    for (const prop of KNOWN_PROPS) {\n      if (changes[prop] && this.inputInstance) {\n        (this.inputInstance as Record<string, unknown>)[prop] = (\n          this as Record<string, unknown>\n        )[prop];\n      }\n    }\n    this.compRef?.changeDetectorRef?.detectChanges();\n  }\n\n  private cleanup(): void {\n    this.cleanupSubscriptions();\n    this.cleanupRenderedComponent();\n  }\n\n  private cleanupSubscriptions(): void {\n    this.subscriptions.forEach((s) => s.unsubscribe());\n    this.subscriptions = [];\n  }\n\n  private cleanupRenderedComponent(): void {\n    this.compRef?.destroy();\n    this.compRef = undefined;\n    this.inputInstance = undefined;\n  }\n\n  private render(): void {\n    const Renderer = fieldRegistry.get(this.type);\n    this.cleanup();\n    this.host.clear();\n\n    if (!Renderer) {\n      this.renderError(`Unknown field type: ${this.type}`);\n      return;\n    }\n\n    if (this.isComponentType(Renderer)) {\n      this.renderComponent(Renderer as unknown as Type<unknown>);\n    } else if (typeof Renderer === 'function') {\n      this.renderFallback(Renderer);\n    } else {\n      this.renderError(`Invalid renderer for type: ${this.type}`);\n    }\n  }\n\n  private isComponentType(renderer: unknown): boolean {\n    return (\n      typeof renderer === 'object' && renderer !== null && 'cmp' in renderer\n    );\n  }\n\n  private renderComponent(compType: Type<unknown>): void {\n    try {\n      const compRef = this.host.createComponent(compType);\n      const instance = compRef.instance;\n\n      if (!instance) {\n        this.renderError(`Failed to create instance for ${this.type}`);\n        return;\n      }\n\n      this.applyProps(instance);\n      this.bindOutputs(instance);\n\n      this.compRef = compRef;\n      this.inputInstance = instance;\n      compRef.changeDetectorRef.detectChanges();\n    } catch {\n      this.renderError(`Failed to render field: ${this.type}`);\n    }\n  }\n\n  private renderFallback(renderer: unknown): void {\n    try {\n      const props = this.getFallbackProps();\n      const result = (renderer as (props: unknown) => string)(props);\n\n      if (typeof result === 'string') {\n        const el = document.createElement('div');\n        el.innerHTML = result;\n        this.host.element.nativeElement.appendChild(el);\n      }\n    } catch {\n      this.renderError(`Failed to render field: ${this.type}`);\n    }\n  }\n\n  private getFallbackProps(): Record<string, unknown> {\n    return {\n      value: this.value,\n      onValueChange: (v: unknown) => this.emitValue(v),\n      label: this.label ?? '',\n      placeholder: this.placeholder ?? '',\n      required: this.required ?? false,\n      options: this.options ?? [],\n      className: this.className ?? '',\n      description: this.description ?? '',\n      disabled: this.disabled ?? false,\n      errorMessage: this.errorMessage ?? '',\n    };\n  }\n\n  private applyProps(instance: unknown): void {\n    const instanceObj = instance as Record<string, unknown>;\n    for (const prop of KNOWN_PROPS) {\n      if (prop in this && prop in instanceObj) {\n        instanceObj[prop] = (this as Record<string, unknown>)[prop];\n      }\n    }\n  }\n\n  private bindOutputs(instance: unknown): void {\n    const outputNames: Array<'valueChange' | 'onValueChange'> = [\n      'valueChange',\n      'onValueChange',\n    ];\n\n    for (const outputName of outputNames) {\n      const output = (instance as Record<string, unknown>)[outputName];\n      if (output && typeof output === 'object' && 'subscribe' in output) {\n        const sub = (\n          output as { subscribe: (cb: (v: unknown) => void) => Subscription }\n        ).subscribe((value: unknown) => this.emitValue(value));\n        this.subscriptions.push(sub);\n      }\n    }\n  }\n\n  private emitValue(value: unknown): void {\n    this.valueChange.emit(value);\n    this.onChange.emit(value);\n  }\n\n  private renderError(message: string): void {\n    const el = document.createElement('div');\n    el.textContent = message;\n    el.style.color = 'red';\n    this.host.element.nativeElement.appendChild(el);\n  }\n}\n"]}

package/dist/esm2022/components/FieldInput.mjs

@@ -0,0 +1,80 @@
+import { NgIf } from '@angular/common';
+import { ChangeDetectionStrategy, Component, EventEmitter, Input, Output, } from '@angular/core';
+import { DynamicInput } from './DynamicInput';
+import * as i0 from "@angular/core";
+export class FieldInput {
+    cdr;
+    fieldDescription;
+    value;
+    onValueChangeField = new EventEmitter();
+    shouldRender = false;
+    constructor(cdr) {
+        this.cdr = cdr;
+    }
+    ngOnChanges(_changes) {
+        this.shouldRender = !!this.fieldDescription;
+        this.cdr.markForCheck();
+    }
+    getFieldValue() {
+        if (!this.fieldDescription) {
+            return undefined;
+        }
+        if (this.value === undefined && this.fieldDescription.type === 'text') {
+            return '';
+        }
+        return this.value;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.20", ngImport: i0, type: FieldInput, deps: [{ token: i0.ChangeDetectorRef }], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "19.2.20", type: FieldInput, isStandalone: true, selector: "dfk-field-input", inputs: { fieldDescription: "fieldDescription", value: "value" }, outputs: { onValueChangeField: "onValueChangeField" }, usesOnChanges: true, ngImport: i0, template: `
+    <dfk-dynamic-input
+      *ngIf="shouldRender"
+      [type]="fieldDescription!.type"
+      [value]="getFieldValue()"
+      [label]="fieldDescription!.label"
+      [placeholder]="fieldDescription!.placeholder"
+      [required]="fieldDescription!.required"
+      [description]="$any(fieldDescription!.description)"
+      [options]="fieldDescription!.options"
+      [className]="fieldDescription!.className"
+      (valueChange)="
+        onValueChangeField.emit({ value: $event, key: fieldDescription!.name })
+      "
+      [disabled]="false"
+      [errorMessage]="''"
+    ></dfk-dynamic-input>
+  `, isInline: true, dependencies: [{ kind: "directive", type: NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "component", type: DynamicInput, selector: "dfk-dynamic-input", inputs: ["type"], outputs: ["valueChange", "onChange"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.20", ngImport: i0, type: FieldInput, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'dfk-field-input',
+                    standalone: true,
+                    imports: [NgIf, DynamicInput],
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: `
+    <dfk-dynamic-input
+      *ngIf="shouldRender"
+      [type]="fieldDescription!.type"
+      [value]="getFieldValue()"
+      [label]="fieldDescription!.label"
+      [placeholder]="fieldDescription!.placeholder"
+      [required]="fieldDescription!.required"
+      [description]="$any(fieldDescription!.description)"
+      [options]="fieldDescription!.options"
+      [className]="fieldDescription!.className"
+      (valueChange)="
+        onValueChangeField.emit({ value: $event, key: fieldDescription!.name })
+      "
+      [disabled]="false"
+      [errorMessage]="''"
+    ></dfk-dynamic-input>
+  `,
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }], propDecorators: { fieldDescription: [{
+                type: Input
+            }], value: [{
+                type: Input
+            }], onValueChangeField: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/dist/esm2022/components/MultiFieldInput.mjs

@@ -0,0 +1,264 @@
+import { NgClass, NgFor, NgIf } from '@angular/common';
+import { ChangeDetectionStrategy, Component, EventEmitter, HostListener, Input, Output, } from '@angular/core';
+import { applyComputedValues, canAddGroupItem, canRemoveGroupItem, createGroupItem, } from '@dynamic-field-kit/core';
+import { FieldInput } from './FieldInput';
+import * as i0 from "@angular/core";
+const DEFAULT_BREAKPOINT = 768;
+export class MultiFieldInput {
+    cdr;
+    fieldDescriptions = [];
+    properties;
+    onChange = new EventEmitter();
+    layout = 'column';
+    data = {};
+    visibleFields = [];
+    isMobile = false;
+    constructor(cdr) {
+        this.cdr = cdr;
+    }
+    onWindowResize() {
+        const wasMobile = this.isMobile;
+        this.updateIsMobile();
+        if (wasMobile !== this.isMobile) {
+            this.cdr.markForCheck();
+        }
+    }
+    get resolvedLayout() {
+        if (typeof this.layout === 'object' && this.layout.type === 'responsive') {
+            return this.isMobile ? this.layout.mobile : this.layout.desktop;
+        }
+        return this.layout;
+    }
+    get resolvedLayoutType() {
+        const resolved = this.resolvedLayout;
+        return typeof resolved === 'string' ? resolved : resolved.type;
+    }
+    get gap() {
+        const resolved = this.resolvedLayout;
+        if (typeof resolved === 'object' && resolved.gap !== undefined) {
+            return resolved.gap;
+        }
+        return 12;
+    }
+    get columns() {
+        const resolved = this.resolvedLayout;
+        if (typeof resolved === 'object' && resolved.type === 'grid') {
+            return resolved.columns ?? 2;
+        }
+        return 2;
+    }
+    trackByFn(index, field) {
+        return field.name || index;
+    }
+    trackByIndex(index) {
+        return index;
+    }
+    ngOnInit() {
+        this.updateIsMobile();
+        this.init();
+    }
+    ngOnChanges(_changes) {
+        this.init();
+    }
+    updateIsMobile() {
+        const breakpoint = typeof this.layout === 'object' && this.layout.type === 'responsive'
+            ? this.layout.breakpoint ?? DEFAULT_BREAKPOINT
+            : DEFAULT_BREAKPOINT;
+        this.isMobile =
+            typeof window !== 'undefined' && window.innerWidth < breakpoint;
+    }
+    init() {
+        if (this.properties) {
+            this.data = applyComputedValues(this.fieldDescriptions, {
+                ...this.properties,
+            });
+        }
+        this.updateVisibleFields();
+    }
+    updateVisibleFields() {
+        this.visibleFields = this.fieldDescriptions.filter((f) => !f.appearCondition || f.appearCondition(this.data));
+    }
+    onFieldChange(event) {
+        this.commitData({ ...this.data, [event.key]: event.value });
+    }
+    getItems(field) {
+        const value = this.data[field.name];
+        return Array.isArray(value) ? value : [];
+    }
+    canAddItem(field) {
+        return canAddGroupItem(field, this.getItems(field));
+    }
+    canRemoveItem(field) {
+        return canRemoveGroupItem(field, this.getItems(field));
+    }
+    onGroupItemAdd(field) {
+        if (!this.canAddItem(field)) {
+            return;
+        }
+        const items = this.getItems(field);
+        this.commitData({
+            ...this.data,
+            [field.name]: [...items, createGroupItem(field)],
+        });
+    }
+    onGroupItemRemove(field, index) {
+        if (!this.canRemoveItem(field)) {
+            return;
+        }
+        const items = this.getItems(field).filter((_, i) => i !== index);
+        this.commitData({ ...this.data, [field.name]: items });
+    }
+    onGroupItemChange(field, index, next) {
+        const items = this.getItems(field).slice();
+        items[index] = next;
+        this.commitData({ ...this.data, [field.name]: items });
+    }
+    commitData(nextData) {
+        this.data = applyComputedValues(this.fieldDescriptions, nextData);
+        this.updateVisibleFields();
+        this.onChange.emit(this.data);
+        this.cdr.markForCheck();
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "19.2.20", ngImport: i0, type: MultiFieldInput, deps: [{ token: i0.ChangeDetectorRef }], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "19.2.20", type: MultiFieldInput, isStandalone: true, selector: "dfk-multi-field-input", inputs: { fieldDescriptions: "fieldDescriptions", properties: "properties", layout: "layout" }, outputs: { onChange: "onChange" }, host: { listeners: { "window:resize": "onWindowResize()" } }, usesOnChanges: true, ngImport: i0, template: `
+    <div
+      class="p-4 border rounded-lg bg-gray-50"
+      [ngClass]="{
+        'flex flex-col': resolvedLayoutType === 'column',
+        'flex flex-row': resolvedLayoutType === 'row',
+        grid: resolvedLayoutType === 'grid'
+      }"
+      [style.gap.px]="gap"
+      [style.gridTemplateColumns]="
+        resolvedLayoutType === 'grid' ? 'repeat(' + columns + ', 1fr)' : null
+      "
+    >
+      <ng-container *ngFor="let field of visibleFields; trackBy: trackByFn">
+        <dfk-field-input
+          *ngIf="!field.fields"
+          [fieldDescription]="field"
+          [value]="data[field.name]"
+          (onValueChangeField)="onFieldChange($event)"
+        ></dfk-field-input>
+
+        <div *ngIf="field.fields" [class]="field.className">
+          <div *ngIf="field.label">{{ field.label }}</div>
+          <div
+            *ngFor="
+              let item of getItems(field);
+              let i = index;
+              trackBy: trackByIndex
+            "
+            style="display: flex; align-items: flex-start; gap: 8px;"
+          >
+            <div style="flex: 1">
+              <dfk-multi-field-input
+                [fieldDescriptions]="field.fields"
+                [properties]="item"
+                (onChange)="onGroupItemChange(field, i, $event)"
+              ></dfk-multi-field-input>
+            </div>
+            <button
+              type="button"
+              (click)="onGroupItemRemove(field, i)"
+              [disabled]="!canRemoveItem(field)"
+            >
+              {{ field.removeLabel || 'Remove' }}
+            </button>
+          </div>
+          <button
+            type="button"
+            (click)="onGroupItemAdd(field)"
+            [disabled]="!canAddItem(field)"
+          >
+            {{ field.addLabel || 'Add' }}
+          </button>
+        </div>
+      </ng-container>
+    </div>
+  `, isInline: true, dependencies: [{ kind: "component", type: MultiFieldInput, selector: "dfk-multi-field-input", inputs: ["fieldDescriptions", "properties", "layout"], outputs: ["onChange"] }, { kind: "directive", type: NgClass, selector: "[ngClass]", inputs: ["class", "ngClass"] }, { kind: "directive", type: NgFor, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { kind: "directive", type: NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "component", type: FieldInput, selector: "dfk-field-input", inputs: ["fieldDescription", "value"], outputs: ["onValueChangeField"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "19.2.20", ngImport: i0, type: MultiFieldInput, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'dfk-multi-field-input',
+                    standalone: true,
+                    // Repeatable field groups render a nested <dfk-multi-field-input> per item
+                    // (see the #groupTpl below), so this component imports itself. That's the
+                    // supported way to give a standalone component recursive template usage
+                    // without a cross-file circular import between FieldInput and a separate
+                    // group component (whose `imports` arrays are evaluated eagerly at module
+                    // load time and would deadlock on an actual circular module reference).
+                    imports: [NgClass, NgFor, NgIf, FieldInput, MultiFieldInput],
+                    changeDetection: ChangeDetectionStrategy.OnPush,
+                    template: `
+    <div
+      class="p-4 border rounded-lg bg-gray-50"
+      [ngClass]="{
+        'flex flex-col': resolvedLayoutType === 'column',
+        'flex flex-row': resolvedLayoutType === 'row',
+        grid: resolvedLayoutType === 'grid'
+      }"
+      [style.gap.px]="gap"
+      [style.gridTemplateColumns]="
+        resolvedLayoutType === 'grid' ? 'repeat(' + columns + ', 1fr)' : null
+      "
+    >
+      <ng-container *ngFor="let field of visibleFields; trackBy: trackByFn">
+        <dfk-field-input
+          *ngIf="!field.fields"
+          [fieldDescription]="field"
+          [value]="data[field.name]"
+          (onValueChangeField)="onFieldChange($event)"
+        ></dfk-field-input>
+
+        <div *ngIf="field.fields" [class]="field.className">
+          <div *ngIf="field.label">{{ field.label }}</div>
+          <div
+            *ngFor="
+              let item of getItems(field);
+              let i = index;
+              trackBy: trackByIndex
+            "
+            style="display: flex; align-items: flex-start; gap: 8px;"
+          >
+            <div style="flex: 1">
+              <dfk-multi-field-input
+                [fieldDescriptions]="field.fields"
+                [properties]="item"
+                (onChange)="onGroupItemChange(field, i, $event)"
+              ></dfk-multi-field-input>
+            </div>
+            <button
+              type="button"
+              (click)="onGroupItemRemove(field, i)"
+              [disabled]="!canRemoveItem(field)"
+            >
+              {{ field.removeLabel || 'Remove' }}
+            </button>
+          </div>
+          <button
+            type="button"
+            (click)="onGroupItemAdd(field)"
+            [disabled]="!canAddItem(field)"
+          >
+            {{ field.addLabel || 'Add' }}
+          </button>
+        </div>
+      </ng-container>
+    </div>
+  `,
+                }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }], propDecorators: { fieldDescriptions: [{
+                type: Input
+            }], properties: [{
+                type: Input
+            }], onChange: [{
+                type: Output
+            }], layout: [{
+                type: Input
+            }], onWindowResize: [{
+                type: HostListener,
+                args: ['window:resize']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"MultiFieldInput.js","sourceRoot":"","sources":["../../../src/components/MultiFieldInput.ts"],"names":[],"mappings":"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","sourcesContent":["import { NgClass, NgFor, NgIf } from '@angular/common';\nimport {\n  ChangeDetectionStrategy,\n  ChangeDetectorRef,\n  Component,\n  EventEmitter,\n  HostListener,\n  Input,\n  OnChanges,\n  OnInit,\n  Output,\n  SimpleChanges,\n} from '@angular/core';\nimport {\n  applyComputedValues,\n  canAddGroupItem,\n  canRemoveGroupItem,\n  createGroupItem,\n  FieldDescription,\n  Properties,\n} from '@dynamic-field-kit/core';\nimport { BaseLayoutConfig, LayoutConfig } from '../types/layout';\nimport { FieldInput } from './FieldInput';\n\nconst DEFAULT_BREAKPOINT = 768;\n\n@Component({\n  selector: 'dfk-multi-field-input',\n  standalone: true,\n  // Repeatable field groups render a nested <dfk-multi-field-input> per item\n  // (see the #groupTpl below), so this component imports itself. That's the\n  // supported way to give a standalone component recursive template usage\n  // without a cross-file circular import between FieldInput and a separate\n  // group component (whose `imports` arrays are evaluated eagerly at module\n  // load time and would deadlock on an actual circular module reference).\n  imports: [NgClass, NgFor, NgIf, FieldInput, MultiFieldInput],\n  changeDetection: ChangeDetectionStrategy.OnPush,\n  template: `\n    <div\n      class=\"p-4 border rounded-lg bg-gray-50\"\n      [ngClass]=\"{\n        'flex flex-col': resolvedLayoutType === 'column',\n        'flex flex-row': resolvedLayoutType === 'row',\n        grid: resolvedLayoutType === 'grid'\n      }\"\n      [style.gap.px]=\"gap\"\n      [style.gridTemplateColumns]=\"\n        resolvedLayoutType === 'grid' ? 'repeat(' + columns + ', 1fr)' : null\n      \"\n    >\n      <ng-container *ngFor=\"let field of visibleFields; trackBy: trackByFn\">\n        <dfk-field-input\n          *ngIf=\"!field.fields\"\n          [fieldDescription]=\"field\"\n          [value]=\"data[field.name]\"\n          (onValueChangeField)=\"onFieldChange($event)\"\n        ></dfk-field-input>\n\n        <div *ngIf=\"field.fields\" [class]=\"field.className\">\n          <div *ngIf=\"field.label\">{{ field.label }}</div>\n          <div\n            *ngFor=\"\n              let item of getItems(field);\n              let i = index;\n              trackBy: trackByIndex\n            \"\n            style=\"display: flex; align-items: flex-start; gap: 8px;\"\n          >\n            <div style=\"flex: 1\">\n              <dfk-multi-field-input\n                [fieldDescriptions]=\"field.fields\"\n                [properties]=\"item\"\n                (onChange)=\"onGroupItemChange(field, i, $event)\"\n              ></dfk-multi-field-input>\n            </div>\n            <button\n              type=\"button\"\n              (click)=\"onGroupItemRemove(field, i)\"\n              [disabled]=\"!canRemoveItem(field)\"\n            >\n              {{ field.removeLabel || 'Remove' }}\n            </button>\n          </div>\n          <button\n            type=\"button\"\n            (click)=\"onGroupItemAdd(field)\"\n            [disabled]=\"!canAddItem(field)\"\n          >\n            {{ field.addLabel || 'Add' }}\n          </button>\n        </div>\n      </ng-container>\n    </div>\n  `,\n})\nexport class MultiFieldInput implements OnInit, OnChanges {\n  @Input() fieldDescriptions: FieldDescription[] = [];\n  @Input() properties?: Properties;\n  @Output() onChange = new EventEmitter<Properties>();\n  @Input() layout: LayoutConfig = 'column';\n\n  data: Properties = {};\n  visibleFields: FieldDescription[] = [];\n  private isMobile = false;\n\n  constructor(private cdr: ChangeDetectorRef) {}\n\n  @HostListener('window:resize')\n  onWindowResize(): void {\n    const wasMobile = this.isMobile;\n    this.updateIsMobile();\n    if (wasMobile !== this.isMobile) {\n      this.cdr.markForCheck();\n    }\n  }\n\n  get resolvedLayout(): BaseLayoutConfig {\n    if (typeof this.layout === 'object' && this.layout.type === 'responsive') {\n      return this.isMobile ? this.layout.mobile : this.layout.desktop;\n    }\n    return this.layout as BaseLayoutConfig;\n  }\n\n  get resolvedLayoutType(): string {\n    const resolved = this.resolvedLayout;\n    return typeof resolved === 'string' ? resolved : resolved.type;\n  }\n\n  get gap(): number {\n    const resolved = this.resolvedLayout;\n    if (typeof resolved === 'object' && resolved.gap !== undefined) {\n      return resolved.gap;\n    }\n    return 12;\n  }\n\n  get columns(): number {\n    const resolved = this.resolvedLayout;\n    if (typeof resolved === 'object' && resolved.type === 'grid') {\n      return resolved.columns ?? 2;\n    }\n    return 2;\n  }\n\n  trackByFn(index: number, field: FieldDescription): string | number {\n    return field.name || index;\n  }\n\n  trackByIndex(index: number): number {\n    return index;\n  }\n\n  ngOnInit() {\n    this.updateIsMobile();\n    this.init();\n  }\n\n  ngOnChanges(_changes: SimpleChanges) {\n    this.init();\n  }\n\n  private updateIsMobile(): void {\n    const breakpoint =\n      typeof this.layout === 'object' && this.layout.type === 'responsive'\n        ? this.layout.breakpoint ?? DEFAULT_BREAKPOINT\n        : DEFAULT_BREAKPOINT;\n    this.isMobile =\n      typeof window !== 'undefined' && window.innerWidth < breakpoint;\n  }\n\n  private init() {\n    if (this.properties) {\n      this.data = applyComputedValues(this.fieldDescriptions, {\n        ...this.properties,\n      });\n    }\n    this.updateVisibleFields();\n  }\n\n  private updateVisibleFields() {\n    this.visibleFields = this.fieldDescriptions.filter(\n      (f) => !f.appearCondition || f.appearCondition(this.data)\n    );\n  }\n\n  onFieldChange(event: { value: unknown; key: string }): void {\n    this.commitData({ ...this.data, [event.key]: event.value });\n  }\n\n  getItems(field: FieldDescription): Properties[] {\n    const value = this.data[field.name];\n    return Array.isArray(value) ? (value as Properties[]) : [];\n  }\n\n  canAddItem(field: FieldDescription): boolean {\n    return canAddGroupItem(field, this.getItems(field));\n  }\n\n  canRemoveItem(field: FieldDescription): boolean {\n    return canRemoveGroupItem(field, this.getItems(field));\n  }\n\n  onGroupItemAdd(field: FieldDescription): void {\n    if (!this.canAddItem(field)) {\n      return;\n    }\n    const items = this.getItems(field);\n    this.commitData({\n      ...this.data,\n      [field.name]: [...items, createGroupItem(field)],\n    });\n  }\n\n  onGroupItemRemove(field: FieldDescription, index: number): void {\n    if (!this.canRemoveItem(field)) {\n      return;\n    }\n    const items = this.getItems(field).filter((_, i) => i !== index);\n    this.commitData({ ...this.data, [field.name]: items });\n  }\n\n  onGroupItemChange(\n    field: FieldDescription,\n    index: number,\n    next: Properties\n  ): void {\n    const items = this.getItems(field).slice();\n    items[index] = next;\n    this.commitData({ ...this.data, [field.name]: items });\n  }\n\n  private commitData(nextData: Properties): void {\n    this.data = applyComputedValues(this.fieldDescriptions, nextData);\n    this.updateVisibleFields();\n    this.onChange.emit(this.data);\n    this.cdr.markForCheck();\n  }\n}\n"]}

package/{esm2020 → dist/esm2022}/dynamic-field-kit-angular.mjs

@@ -1,5 +1,5 @@
-/**
- * Generated bundle index. Do not edit.
- */
-export * from './public-api';
+/**
+ * Generated bundle index. Do not edit.
+ */
+export * from './public-api';
 //# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZHluYW1pYy1maWVsZC1raXQtYW5ndWxhci5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9keW5hbWljLWZpZWxkLWtpdC1hbmd1bGFyLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOztHQUVHO0FBRUgsY0FBYyxjQUFjLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIEdlbmVyYXRlZCBidW5kbGUgaW5kZXguIERvIG5vdCBlZGl0LlxuICovXG5cbmV4cG9ydCAqIGZyb20gJy4vcHVibGljLWFwaSc7XG4iXX0=