@tstdl/base 0.91.41 → 0.91.42

package/form/controls/number.control.js

@@ -1,73 +0,0 @@
-import { decimalFormat, formatNumber, integerFormat, yearFormat } from '../../formats.js';
-import { getNumberParser } from '../../intl/number-parser.js';
-import { isDefined, isNull, isNumber } from '../../utils/type-guards.js';
-import { computedInternalValidators } from '../abstract-control.js';
-import { FormControl } from '../form-control.js';
-import { reactiveOptionToSignal } from '../utils.js';
-import { numberValidator } from '../validators/number.validator.js';
-const numberParser = getNumberParser('de');
-export class NumberFormControl extends FormControl {
-    internalValidators = computedInternalValidators(() => {
-        const minimum = this.minimum();
-        const maximum = this.maximum();
-        return [(isDefined(minimum) || isDefined(maximum)) ? numberValidator(minimum, maximum) : undefined];
-    });
-    autocomplete;
-    placeholder;
-    integer;
-    format;
-    minimum;
-    maximum;
-    step;
-    constructor(initialValue, options = {}) {
-        super(initialValue, options);
-        this.autocomplete = reactiveOptionToSignal(options.autocomplete ?? 'off', { initialValue: 'off' });
-        this.placeholder = reactiveOptionToSignal(options.placeholder ?? null, { initialValue: null });
-        this.integer = reactiveOptionToSignal(options.integer ?? false, { initialValue: false });
-        this.format = reactiveOptionToSignal(options.format ?? decimalFormat, { initialValue: decimalFormat });
-        this.minimum = reactiveOptionToSignal(options.minimum ?? null, { initialValue: null });
-        this.maximum = reactiveOptionToSignal(options.maximum ?? null, { initialValue: null });
-        this.step = reactiveOptionToSignal(options.step ?? null, { initialValue: null });
-    }
-    parseRawValue(value) {
-        if (isNumber(value) && this.integer()) {
-            return Math.floor(value);
-        }
-        return value;
-    }
-    parseInputValue(value) {
-        if (isNull(value) || (value.trim().length == 0)) {
-            return null;
-        }
-        const parsed = numberParser.parse(value, true);
-        return this.integer() ? Math.floor(parsed) : parsed;
-    }
-    formatRawValue(value) {
-        if (isNull(value)) {
-            return '';
-        }
-        const valueToFormat = this.integer() ? Math.floor(value) : value;
-        return formatNumber(valueToFormat, this.format());
-    }
-}
-export function numberFormControl(options) {
-    return new NumberFormControl(null, options);
-}
-export function integerNumberControl(options) {
-    return numberFormControl({
-        integer: true,
-        format: integerFormat,
-        ...options
-    });
-}
-export function yearNumberControl(options) {
-    return integerNumberControl({
-        format: yearFormat,
-        minimum: 1600,
-        maximum: 2200,
-        ...options,
-    });
-}
-export function isNumberFormControl(value) {
-    return (value instanceof NumberFormControl);
-}

package/form/controls/radio-group.control.d.ts

@@ -1,22 +0,0 @@
-import type { Signal } from '../../signals/api.js';
-import type { EnumerationObject, FilledReadonlyArray, TypedOmit } from '../../types.js';
-import type { InitialValue, InitialValueOption } from '../form-control.js';
-import { ItemsFormControl, type ItemsFormControlOptions } from './items.control.js';
-export type RadioGroupFormControlDirection = 'row' | 'column';
-export type RadioGroupFormControlOptions<T, I extends InitialValue<T>> = ItemsFormControlOptions<T, I> & {
-    direction?: RadioGroupFormControlDirection;
-};
-export declare class RadioGroupFormControl<T, I extends InitialValue<T> = T | null> extends ItemsFormControl<T, I> {
-    readonly direction: Signal<RadioGroupFormControlDirection>;
-    constructor(initialValue: I, options: RadioGroupFormControlOptions<T, I>);
-}
-export declare function radioGroupFormControl<T, I extends InitialValue<T>>(options: RadioGroupFormControlOptions<T, I> & InitialValueOption<I>): RadioGroupFormControl<T, I>;
-export declare function radioGroupFormControl<T, I extends InitialValue<T>>(options: RadioGroupFormControlOptions<T, I>): RadioGroupFormControl<T, T | null>;
-export declare function booleanRadioGroupFormControl<I extends InitialValue<boolean>>(options: TypedOmit<RadioGroupFormControlOptions<boolean, I>, 'items'> & InitialValueOption<I>): RadioGroupFormControl<boolean, I>;
-export declare function booleanRadioGroupFormControl<I extends InitialValue<boolean>>(options?: TypedOmit<RadioGroupFormControlOptions<boolean, I>, 'items'>): RadioGroupFormControl<boolean>;
-export type EnumRadioGroupFormControlOptions<T extends EnumerationObject, I extends InitialValue<T[keyof T]>> = TypedOmit<RadioGroupFormControlOptions<T[keyof T], I>, 'items'> & {
-    allowedValues?: FilledReadonlyArray<T[keyof T]>;
-};
-export declare function enumRadioGroupFormControl<T extends EnumerationObject, I extends InitialValue<T[keyof T]>>(enumeration: T, options: EnumRadioGroupFormControlOptions<T, I> & InitialValueOption<I>): RadioGroupFormControl<T[keyof T], I>;
-export declare function enumRadioGroupFormControl<T extends EnumerationObject, I extends InitialValue<T[keyof T]>>(enumeration: T, options?: EnumRadioGroupFormControlOptions<T, I>): RadioGroupFormControl<T[keyof T]>;
-export declare function isRadioGroupFormControl(value: any): value is RadioGroupFormControl<any, any>;

package/form/controls/radio-group.control.js

@@ -1,28 +0,0 @@
-import { tstdlCommonLocalizationKeys } from '../../text/common-localization.js';
-import { enumAsItems, reactiveOptionToSignal } from '../utils.js';
-import { ItemsFormControl } from './items.control.js';
-export class RadioGroupFormControl extends ItemsFormControl {
-    direction;
-    constructor(initialValue, options) {
-        super(initialValue, options);
-        this.direction = reactiveOptionToSignal(options.direction ?? 'column', { initialValue: 'column' });
-    }
-}
-export function radioGroupFormControl(options) {
-    return new RadioGroupFormControl(null, options);
-}
-export function booleanRadioGroupFormControl(options = {}) {
-    return radioGroupFormControl({
-        ...options,
-        items: [{ label: tstdlCommonLocalizationKeys.yes, value: true }, { label: tstdlCommonLocalizationKeys.no, value: false }]
-    });
-}
-export function enumRadioGroupFormControl(enumeration, options = {}) {
-    return radioGroupFormControl({
-        ...options,
-        items: enumAsItems(enumeration, options.allowedValues)
-    });
-}
-export function isRadioGroupFormControl(value) {
-    return (value instanceof RadioGroupFormControl);
-}

package/form/controls/select.control.d.ts

@@ -1,17 +0,0 @@
-import type { EnumerationObject, FilledReadonlyArray, TypedOmit } from '../../types.js';
-import type { InitialValue, InitialValueOption } from '../form-control.js';
-import { ItemsFormControl, type ItemsFormControlOptions } from './items.control.js';
-export type SelectFormControlOptions<T, I extends InitialValue<T>> = ItemsFormControlOptions<T, I>;
-export declare class SelectFormControl<T, I extends InitialValue<T> = T | null> extends ItemsFormControl<T, I> {
-    constructor(initialValue: I, options: SelectFormControlOptions<T, I>);
-}
-export declare function selectFormControl<T, I extends InitialValue<T>>(options: SelectFormControlOptions<T, I> & InitialValueOption<I>): SelectFormControl<T, I>;
-export declare function selectFormControl<T, I extends InitialValue<T>>(options: SelectFormControlOptions<T, I>): SelectFormControl<T, T | null>;
-export declare function booleanSelectFormControl<I extends InitialValue<boolean>>(options: TypedOmit<SelectFormControlOptions<boolean, I>, 'items'> & InitialValueOption<I>): SelectFormControl<boolean, I>;
-export declare function booleanSelectFormControl<I extends InitialValue<boolean>>(options?: TypedOmit<SelectFormControlOptions<boolean, I>, 'items'>): SelectFormControl<boolean>;
-export type EnumSelectFormControlOptions<T extends EnumerationObject, I extends InitialValue<T[keyof T]>> = TypedOmit<SelectFormControlOptions<T[keyof T], I>, 'items'> & {
-    allowedValues?: FilledReadonlyArray<T[keyof T]>;
-};
-export declare function enumSelectFormControl<T extends EnumerationObject, I extends InitialValue<T[keyof T]>>(enumeration: T, options: EnumSelectFormControlOptions<T, I> & InitialValueOption<I>): SelectFormControl<T[keyof T], I>;
-export declare function enumSelectFormControl<T extends EnumerationObject, I extends InitialValue<T[keyof T]>>(enumeration: T, options?: EnumSelectFormControlOptions<T, I>): SelectFormControl<T[keyof T]>;
-export declare function isSelectFormControl(value: any): value is SelectFormControl<any, any>;

package/form/controls/select.control.js

@@ -1,26 +0,0 @@
-import { tstdlCommonLocalizationKeys } from '../../text/common-localization.js';
-import { enumAsItems } from '../utils.js';
-import { ItemsFormControl } from './items.control.js';
-export class SelectFormControl extends ItemsFormControl {
-    constructor(initialValue, options) {
-        super(initialValue, options);
-    }
-}
-export function selectFormControl(options) {
-    return new SelectFormControl(null, options);
-}
-export function booleanSelectFormControl(options = {}) {
-    return selectFormControl({
-        ...options,
-        items: [{ label: tstdlCommonLocalizationKeys.yes, value: true }, { label: tstdlCommonLocalizationKeys.no, value: false }]
-    });
-}
-export function enumSelectFormControl(enumeration, options = {}) {
-    return selectFormControl({
-        ...options,
-        items: enumAsItems(enumeration, options.allowedValues)
-    });
-}
-export function isSelectFormControl(value) {
-    return (value instanceof SelectFormControl);
-}

package/form/controls/text.control.d.ts

@@ -1,47 +0,0 @@
-import { type Signal } from '../../signals/index.js';
-import type { ReactiveValue, TypedOmit } from '../../types.js';
-import type { InputAutocomplete } from '../../web-types.js';
-import { FormControl, type FormControlOptions, type InitialValue, type InitialValueOption } from '../form-control.js';
-import type { DynamicTextOption } from '../types.js';
-export type TextFormControlType = 'text' | 'password' | 'email';
-export type AutoFillSuggestionSelectHandler<T = any> = (suggestion: AutoFillSuggestion<T>) => any;
-export type AutoFillSuggestion<T = any> = {
-    display: ReactiveValue<string>;
-    selectValue?: string;
-    data?: T;
-    onSelect?: AutoFillSuggestionSelectHandler<T>;
-};
-export type NormalizedAutoFillSuggestion<T = any> = TypedOmit<AutoFillSuggestion<T>, 'display'> & {
-    display: Signal<string>;
-    searchText: Signal<string>;
-};
-export type TextFormControlOptions<I extends InitialValue<string> = InitialValue<string>> = FormControlOptions<string | I> & {
-    type?: ReactiveValue<TextFormControlType>;
-    autocomplete?: ReactiveValue<InputAutocomplete>;
-    placeholder?: ReactiveValue<DynamicTextOption>;
-    pattern?: ReactiveValue<RegExp | null>;
-    inputPattern?: ReactiveValue<RegExp | null>;
-    trim?: ReactiveValue<boolean>;
-    maxLength?: ReactiveValue<number>;
-    autoFillSuggestions?: ReactiveValue<(string | AutoFillSuggestion)[] | undefined>;
-    filterAutoFillSuggestions?: ReactiveValue<boolean>;
-};
-export declare class TextFormControl<I extends InitialValue<string> = string | null> extends FormControl<string | I, string> {
-    protected readonly internalValidators: Signal<readonly import("../validators/form.validator.js").FormValidator<any>[]>;
-    readonly type: Signal<TextFormControlType>;
-    readonly autocomplete: Signal<InputAutocomplete>;
-    readonly placeholder: Signal<DynamicTextOption>;
-    readonly pattern: Signal<RegExp | null>;
-    readonly inputPattern: Signal<RegExp | null>;
-    readonly trim: Signal<boolean>;
-    readonly maxLength: Signal<number | null>;
-    readonly autoFillSuggestions: Signal<readonly NormalizedAutoFillSuggestion[] | null>;
-    readonly filterAutoFillSuggestions: Signal<boolean>;
-    readonly filteredAutoFillSuggestions: Signal<readonly NormalizedAutoFillSuggestion[] | null>;
-    constructor(initialValue: I, options?: TextFormControlOptions<I>);
-    parseInputValue(value: string | null): string | I | null;
-    formatRawValue(value: string | null): string;
-}
-export declare function textFormControl<I extends InitialValue<string>>(options: TextFormControlOptions<I> & InitialValueOption<I>): TextFormControl<I>;
-export declare function textFormControl<I extends InitialValue<string>>(options?: TextFormControlOptions<I>): TextFormControl;
-export declare function isTextFormControl(value: any): value is TextFormControl<any>;

package/form/controls/text.control.js

@@ -1,94 +0,0 @@
-import { computed, getCurrentSignalsInjector, runInSignalsInjectionContext } from '../../signals/index.js';
-import { normalizeText } from '../../utils/helpers.js';
-import { mailPattern } from '../../utils/patterns.js';
-import { isNotNull, isNull, isNumber, isString } from '../../utils/type-guards.js';
-import { computedInternalValidators } from '../abstract-control.js';
-import { FormControl } from '../form-control.js';
-import { reactiveOptionToSignal } from '../utils.js';
-import { maxLengthValidator, patternValidator } from '../validators/index.js';
-export class TextFormControl extends FormControl {
-    internalValidators = computedInternalValidators(() => {
-        const pattern = this.pattern();
-        const maxLength = this.maxLength();
-        const type = this.type();
-        return [
-            isNumber(maxLength) ? maxLengthValidator(maxLength) : null,
-            (type == 'email') ? patternValidator(mailPattern) : null,
-            isNotNull(pattern) ? patternValidator(pattern) : null
-        ];
-    });
-    type;
-    autocomplete;
-    placeholder;
-    pattern;
-    inputPattern;
-    trim;
-    maxLength;
-    autoFillSuggestions;
-    filterAutoFillSuggestions;
-    filteredAutoFillSuggestions;
-    constructor(initialValue, options = {}) {
-        super(initialValue, options);
-        this.type = reactiveOptionToSignal(options.type ?? 'text', { initialValue: 'text' });
-        this.autocomplete = reactiveOptionToSignal(options.autocomplete ?? 'off', { initialValue: 'off' });
-        this.placeholder = reactiveOptionToSignal(options.placeholder ?? null, { initialValue: null });
-        this.pattern = reactiveOptionToSignal(options.pattern ?? null, { initialValue: null });
-        this.inputPattern = reactiveOptionToSignal(options.inputPattern ?? null, { initialValue: null });
-        this.trim = reactiveOptionToSignal(options.trim ?? true, { initialValue: true });
-        this.maxLength = reactiveOptionToSignal(options.maxLength ?? null, { initialValue: null });
-        const rawAutoFillSuggestions = reactiveOptionToSignal(options.autoFillSuggestions);
-        const signalsInjector = getCurrentSignalsInjector();
-        this.autoFillSuggestions = computed(() => runInSignalsInjectionContext(signalsInjector, () => normalizeAutoFillSuggestions(rawAutoFillSuggestions() ?? null)));
-        this.filterAutoFillSuggestions = reactiveOptionToSignal(options.filterAutoFillSuggestions ?? true, { initialValue: true });
-        this.filteredAutoFillSuggestions = computed(() => {
-            const searchValue = normalizeText(this.value() ?? '');
-            const autoFillSuggestions = this.autoFillSuggestions();
-            if (isNull(autoFillSuggestions)) {
-                return null;
-            }
-            if (!this.filterAutoFillSuggestions() || (searchValue.length == 0)) {
-                return autoFillSuggestions;
-            }
-            return autoFillSuggestions.filter((suggestion) => suggestion.searchText().includes(searchValue));
-        });
-    }
-    parseInputValue(value) {
-        if (isNull(value)) {
-            return null;
-        }
-        const normalized = this.trim() ? value.trim() : value;
-        if (normalized.length == 0) {
-            return null;
-        }
-        return normalized;
-    }
-    formatRawValue(value) {
-        return value ?? '';
-    }
-}
-export function textFormControl(options) {
-    return new TextFormControl(null, options);
-}
-export function isTextFormControl(value) {
-    return (value instanceof TextFormControl);
-}
-function normalizeAutoFillSuggestions(suggestions) {
-    if (isNull(suggestions)) {
-        return null;
-    }
-    return suggestions.map((suggestion) => {
-        if (isString(suggestion)) {
-            return {
-                display: computed(() => suggestion),
-                searchText: computed(() => normalizeText(suggestion)),
-                data: suggestion
-            };
-        }
-        const displaySignal = reactiveOptionToSignal(suggestion.display, { requireSync: true });
-        return {
-            ...suggestion,
-            display: displaySignal,
-            searchText: computed(() => normalizeText(displaySignal()))
-        };
-    });
-}

package/form/controls/time.control.d.ts

@@ -1,24 +0,0 @@
-import type { Signal } from '../../signals/api.js';
-import type { ReactiveValue } from '../../types.js';
-import type { InputAutocomplete } from '../../web-types.js';
-import { FormControl, type FormControlOptions, type InitialValue, type InitialValueOption } from '../form-control.js';
-import type { DynamicTextOption } from '../types.js';
-export type TimeFormControlOptions<I extends InitialValue<number> = InitialValue<number>> = FormControlOptions<number | I> & {
-    autocomplete?: InputAutocomplete;
-    placeholder?: ReactiveValue<DynamicTextOption>;
-    minimum?: ReactiveValue<number | null>;
-    maximum?: ReactiveValue<number | null>;
-};
-export declare class TimeFormControl<I extends InitialValue<number> = number | null> extends FormControl<number | I, string> {
-    protected readonly internalValidators: Signal<readonly import("../index.js").FormValidator<any>[]>;
-    readonly autocomplete: Signal<InputAutocomplete>;
-    readonly placeholder: Signal<DynamicTextOption>;
-    readonly minimum: Signal<number | null>;
-    readonly maximum: Signal<number | null>;
-    constructor(initialValue: I, options?: TimeFormControlOptions<I>);
-    parseInputValue(value: string | null): number | null;
-    formatRawValue(value: number | null): string;
-}
-export declare function timeFormControl<I extends InitialValue<number>>(options: TimeFormControlOptions<I> & InitialValueOption<I>): TimeFormControl<I>;
-export declare function timeFormControl<I extends InitialValue<number>>(options?: TimeFormControlOptions<I>): TimeFormControl;
-export declare function isTimeFormControl(value: any): value is TimeFormControl<any>;

package/form/controls/time.control.js

@@ -1,44 +0,0 @@
-import { Duration } from 'luxon';
-import { isDefined, isNull } from '../../utils/type-guards.js';
-import { millisecondsPerHour, millisecondsPerMinute, millisecondsPerSecond } from '../../utils/units.js';
-import { computedInternalValidators } from '../abstract-control.js';
-import { FormControl } from '../form-control.js';
-import { reactiveOptionToSignal } from '../utils.js';
-import { timeValidator } from '../validators/time.validator.js';
-export class TimeFormControl extends FormControl {
-    internalValidators = computedInternalValidators(() => {
-        const minimum = this.minimum();
-        const maximum = this.maximum();
-        return [(isDefined(minimum) || isDefined(maximum)) ? timeValidator(minimum, maximum) : undefined];
-    });
-    autocomplete;
-    placeholder;
-    minimum;
-    maximum;
-    constructor(initialValue, options = {}) {
-        super(initialValue, options);
-        this.autocomplete = reactiveOptionToSignal(options.autocomplete ?? 'off', { initialValue: 'off' });
-        this.placeholder = reactiveOptionToSignal(options.placeholder ?? null, { initialValue: null });
-        this.minimum = reactiveOptionToSignal(options.minimum ?? null, { initialValue: null });
-        this.maximum = reactiveOptionToSignal(options.maximum ?? null, { initialValue: null });
-    }
-    parseInputValue(value) {
-        if (isNull(value)) {
-            return null;
-        }
-        const [hours, minutes, seconds] = value.split(':').map((part) => Number(part));
-        return ((hours ?? 0) * millisecondsPerHour) + ((minutes ?? 0) * millisecondsPerMinute) + ((seconds ?? 0) * millisecondsPerSecond);
-    }
-    formatRawValue(value) {
-        if (isNull(value) || Number.isNaN(value)) {
-            return '';
-        }
-        return Duration.fromMillis(value).toFormat('hh:mm');
-    }
-}
-export function timeFormControl(options) {
-    return new TimeFormControl(null, options);
-}
-export function isTimeFormControl(value) {
-    return (value instanceof TimeFormControl);
-}

package/form/form-array.d.ts

@@ -1,71 +0,0 @@
-import type { JsonPath } from '../json-path/json-path.js';
-import { type Signal } from '../signals/api.js';
-import type { ReactiveValue } from '../types.js';
-import { type AbstractControl, type AbstractControlParent, type AbstractControlRawValueType, type AbstractControlValueType, type MarkOptions } from './abstract-control.js';
-import { FormContainer, type FormContainerOptions } from './form-container.js';
-import type { FormControlRemoveHandler } from './types.js';
-import type { FormValidatorError } from './validators/form.validator.js';
-export type FormArrayDisplayType = 'simple' | 'tabs';
-export type FormArrayChildBuilder<T = unknown, TRaw = unknown, C extends AbstractControl<T, TRaw> = AbstractControl<T, TRaw>> = (value: T) => C;
-export type FormArrayOptions<T, TRaw, C extends AbstractControl<T, TRaw>> = FormContainerOptions<T[]> & {
-    children?: C[];
-    displayType?: FormArrayDisplayType;
-    allowRemove?: ReactiveValue<boolean>;
-    allowRemoveAll?: ReactiveValue<boolean>;
-    removeHandler?: FormControlRemoveHandler<C & {}>;
-    builder?: FormArrayChildBuilder<T, TRaw, C>;
-};
-export type FormArrayByControl<C extends AbstractControl = AbstractControl> = FormArray<AbstractControlValueType<C>, AbstractControlRawValueType<C>, C>;
-export type FormArrayChild<T extends FormArray> = ReturnType<T['children']>[number];
-export declare class FormArray<T = any, TRaw = any, C extends AbstractControl<T, TRaw> = AbstractControl<T, TRaw>> extends FormContainer<T[], TRaw[]> implements Iterable<C> {
-    #private;
-    protected readonly internalValidators: null;
-    readonly children: Signal<readonly C[]>;
-    readonly enabledChildren: Signal<readonly C[]>;
-    readonly size: Signal<number>;
-    readonly displayType: Signal<FormArrayDisplayType>;
-    readonly allowRemove: Signal<boolean>;
-    readonly allowRemoveAll: Signal<boolean>;
-    readonly removedChildren: Signal<C[]>;
-    readonly removeHandler: FormControlRemoveHandler<any>;
-    readonly builder: FormArrayChildBuilder<T, TRaw, C>;
-    /** Raw values of all children whether disabled or not */
-    readonly rawValue: Signal<TRaw[]>;
-    /** Values of all enabled children */
-    readonly value: Signal<T[]>;
-    readonly dirty: Signal<boolean>;
-    readonly touched: Signal<boolean>;
-    readonly localErrors: Signal<readonly FormValidatorError[]>;
-    readonly childrenErrors: Signal<FormValidatorError[]>;
-    readonly errors: Signal<FormValidatorError[]>;
-    readonly errorDebug: Signal<{
-        _self: readonly FormValidatorError[];
-    } | null>;
-    constructor(options?: FormArrayOptions<T, TRaw, C>);
-    get(index: number): C | undefined;
-    getValue(index: number): T | undefined;
-    getRawValue(index: number): TRaw | undefined;
-    reset(): void;
-    indexOf(child: C): number | null;
-    add(...children: C[]): void;
-    addValue(...values: T[]): void;
-    removeAll(): void;
-    remove(child: C): void;
-    removeAt(index: number, count?: number): void;
-    setValue(values: T[]): void;
-    markAsDirty({ onlySelf }?: MarkOptions): void;
-    markAsTouched({ onlySelf }?: MarkOptions): void;
-    setParent(parent: AbstractControlParent, force?: boolean): void;
-    setParent(parent: null): void;
-    [Symbol.iterator](): Iterator<C>;
-    getChildPath(child: C): Signal<JsonPath>;
-    private updateParents;
-}
-export declare function formArray<C extends AbstractControl>(options: FormArrayOptions<AbstractControlValueType<C>, AbstractControlRawValueType<C>, C> & {
-    builder: FormArrayChildBuilder<AbstractControlValueType<C>, AbstractControlRawValueType<C>, C>;
-}): FormArray<AbstractControlValueType<C>, AbstractControlRawValueType<C>, C>;
-export declare function formArray<C extends AbstractControl>(options: FormArrayOptions<AbstractControlValueType<C>, AbstractControlRawValueType<C>, C> & {
-    children: C[];
-}): FormArray<AbstractControlValueType<C>, AbstractControlRawValueType<C>, C>;
-export declare function formArray<T, TRaw, C extends AbstractControl>(options: FormArrayOptions<T, TRaw, C>): FormArray<T, TRaw, C>;
-export declare function isFormArray(value: any): value is FormArray;

package/form/form-array.js

@@ -1,188 +0,0 @@
-import { computed, signal, untracked } from '../signals/api.js';
-import { switchAll } from '../signals/index.js';
-import { createArray } from '../utils/array/array.js';
-import { fromEntries } from '../utils/object/object.js';
-import { deferThrow } from '../utils/throw.js';
-import { isDefined, isNotNull } from '../utils/type-guards.js';
-import { ignoreFormValue } from './abstract-control.js';
-import { FormContainer } from './form-container.js';
-import { bindReactiveOption } from './utils.js';
-export class FormArray extends FormContainer {
-    #children = signal([]);
-    #selfTouched = signal(false);
-    #selfDirty = signal(false);
-    #displayType = signal('tabs');
-    #allowRemove = signal(true);
-    #allowRemoveAll = signal(true);
-    #removedChildren = signal(new Set());
-    internalValidators = null;
-    children = this.#children.asReadonly();
-    enabledChildren = computed(() => this.#children().filter((child) => child.enabled()));
-    size = computed(() => this.children().length);
-    displayType = this.#displayType.asReadonly();
-    allowRemove = this.#allowRemove.asReadonly();
-    allowRemoveAll = this.#allowRemoveAll.asReadonly();
-    removedChildren = computed(() => [...this.#removedChildren()]);
-    removeHandler;
-    builder;
-    /** Raw values of all children whether disabled or not */
-    rawValue = computed(() => this.#children().map((child) => child.rawValue()));
-    /** Values of all enabled children */
-    value = computed(() => this.enabledChildren().map((child) => child.value()));
-    dirty = computed(() => this.#selfDirty() || this.children().some((child) => child.dirty()));
-    touched = computed(() => this.#selfTouched() || this.children().some((child) => child.touched()));
-    localErrors = switchAll(() => {
-        const validations = this.validators().map((validator) => validator(this));
-        return computed(() => validations.map((validation) => validation()).filter(isNotNull));
-    });
-    childrenErrors = computed(() => this.children().flatMap((child) => child.errors()));
-    errors = computed(() => [
-        ...this.localErrors(),
-        ...this.childrenErrors()
-    ]);
-    errorDebug = computed(() => this.valid()
-        ? null
-        : ({
-            _self: this.localErrors(),
-            ...fromEntries(this.children().map((child, index) => [index, child.errorDebug()]).filter(([, errorDebug]) => isNotNull(errorDebug)))
-        }));
-    constructor(options = {}) {
-        super(options);
-        this.builder = options.builder ?? deferThrow(() => new Error('Builder required to add children by value'));
-        this.removeHandler = options.removeHandler ?? (() => true);
-        if (isDefined(options.children)) {
-            this.add(...options.children);
-        }
-        bindReactiveOption(options.displayType, this.#displayType);
-        bindReactiveOption(options.allowRemove, this.#allowRemove);
-        bindReactiveOption(options.allowRemoveAll, this.#allowRemoveAll);
-    }
-    get(index) {
-        return this.children()[index];
-    }
-    getValue(index) {
-        return this.get(index)?.value();
-    }
-    getRawValue(index) {
-        return this.get(index)?.rawValue();
-    }
-    reset() {
-        for (const child of untracked(this.#children)) {
-            child.reset();
-        }
-        this.#removedChildren.set(new Set());
-    }
-    indexOf(child) {
-        const index = untracked(this.children).indexOf(child);
-        return (index == -1) ? null : index;
-    }
-    add(...children) {
-        this.#children.set([...untracked(this.children), ...children]);
-        for (const child of children) {
-            child.setParent(this);
-        }
-    }
-    addValue(...values) {
-        const children = values.map((value) => this.builder(value));
-        this.add(...children);
-    }
-    removeAll() {
-        const newlyRemovedChildren = [];
-        for (const child of untracked(this.children)) {
-            if (untracked(child.parent) == this) {
-                child.setParent(null);
-            }
-            newlyRemovedChildren.push(child);
-        }
-        this.#removedChildren.update((removedChildren) => new Set([...removedChildren, ...newlyRemovedChildren]));
-        this.#children.set([]);
-    }
-    remove(child) {
-        const index = this.indexOf(child);
-        if (isNotNull(index)) {
-            this.removeAt(index);
-        }
-    }
-    removeAt(index, count = 1) {
-        const children = untracked(this.children);
-        const newlyRemovedChildren = [];
-        const end = Math.min(index + count, children.length);
-        if (end <= index) {
-            return;
-        }
-        for (let i = index; i < end; i++) {
-            const child = children[i];
-            child.setParent(null);
-            newlyRemovedChildren.push(child);
-        }
-        const spliced = children.toSpliced(index, 1);
-        this.#removedChildren.update((removedChildren) => new Set([...removedChildren, ...newlyRemovedChildren]));
-        this.#children.set(spliced);
-    }
-    setValue(values) {
-        if (values == ignoreFormValue) {
-            return;
-        }
-        let children = untracked(this.#children);
-        const newlyRemovedChildren = [];
-        if (values.length < children.length) {
-            for (let i = values.length; i < children.length - 1; i++) {
-                const child = children[i];
-                child.setParent(null);
-                newlyRemovedChildren.push(child);
-            }
-            children = children.slice(0, values.length);
-        }
-        else if (values.length > children.length) {
-            const newChildren = createArray(values.length - children.length, (index) => this.builder(values[children.length + index]));
-            children = [...children, ...newChildren];
-        }
-        for (let i = 0; i < values.length; i++) {
-            children[i].setValue(values[i]);
-        }
-        this.#removedChildren.update((removedChildren) => new Set([...removedChildren, ...newlyRemovedChildren]));
-        this.#children.set(children);
-    }
-    markAsDirty({ onlySelf = false } = {}) {
-        this.#selfDirty.set(true);
-        if (onlySelf) {
-            return;
-        }
-        for (const child of untracked(this.children)) {
-            child.markAsDirty();
-        }
-    }
-    markAsTouched({ onlySelf = false } = {}) {
-        this.#selfTouched.set(true);
-        if (onlySelf) {
-            return;
-        }
-        for (const child of untracked(this.children)) {
-            child.markAsTouched();
-        }
-    }
-    setParent(parent, force) {
-        super.setParent(parent, force);
-        this.updateParents(true);
-    }
-    *[Symbol.iterator]() {
-        yield* untracked(this.children);
-    }
-    getChildPath(child) {
-        return computed(() => {
-            const key = this.#children().indexOf(child);
-            return this.path().add((key >= 0) ? key : 'CHILD_NOT_FOUND');
-        });
-    }
-    updateParents(force) {
-        for (const child of untracked(this.#children)) {
-            child.setParent(this, force);
-        }
-    }
-}
-export function formArray(options) {
-    return new FormArray(options); // eslint-disable-line @typescript-eslint/no-unsafe-return
-}
-export function isFormArray(value) {
-    return (value instanceof FormArray);
-}