@tstdl/base 0.91.41 → 0.91.43

package/form/form-button.d.ts

@@ -1,41 +0,0 @@
-import type { PartialProperty, ReactiveValue, TypedOmit } from '../types.js';
-import type { FormDialog } from './form-dialog.js';
-import { FormHeaderFooterElement, type FormHeaderFooterElementOptions } from './form-header-footer-element.js';
-import type { DynamicTextOption } from './types.js';
-export type FormButtonSize = 'normal' | 'small';
-export type FormButtonColor = 'transparent' | 'white' | 'accent' | 'neutral' | 'stone' | 'red' | 'orange' | 'amber' | 'yellow' | 'lime' | 'green' | 'emerald' | 'teal' | 'cyan' | 'sky' | 'blue' | 'indigo' | 'violet' | 'purple' | 'fuchsia' | 'pink' | 'rose';
-export type FormButtonType = 'button' | 'submit' | 'reset';
-export type FormButtonDesign = 'flat' | 'outline' | 'icon' | 'icon-outline' | 'none';
-export type IconLocation = 'before' | 'after';
-export type IconSize = 'small' | 'normal';
-export type FormButtonHandler = () => any;
-export type FormButtonOptions = FormHeaderFooterElementOptions & {
-    handler: FormButtonHandler;
-    label?: ReactiveValue<DynamicTextOption>;
-    type?: ReactiveValue<FormButtonType | null>;
-    disabled?: ReactiveValue<boolean | null>;
-    design?: ReactiveValue<FormButtonDesign | null>;
-    color?: ReactiveValue<FormButtonColor | null>;
-    icon?: ReactiveValue<string | null>;
-    iconLocation?: ReactiveValue<IconLocation | null>;
-    iconSize?: ReactiveValue<IconSize | null>;
-};
-export declare class FormButton extends FormHeaderFooterElement {
-    #private;
-    readonly handler: FormButtonHandler;
-    readonly label: import("../signals/api.js").Signal<DynamicTextOption>;
-    readonly type: import("../signals/api.js").Signal<FormButtonType>;
-    readonly disabled: import("../signals/api.js").Signal<boolean>;
-    readonly style: import("../signals/api.js").Signal<FormButtonDesign>;
-    readonly color: import("../signals/api.js").Signal<FormButtonColor>;
-    readonly icon: import("../signals/api.js").Signal<string | null>;
-    readonly iconLocation: import("../signals/api.js").Signal<IconLocation>;
-    readonly iconSize: import("../signals/api.js").Signal<IconSize>;
-    constructor(options: FormButtonOptions);
-}
-export declare function formButton(options: FormButtonOptions): FormButton;
-export declare function dialogFormButton(options: {
-    dialog: FormDialog;
-    showErrors?: boolean;
-} & TypedOmit<PartialProperty<FormButtonOptions, 'handler'>, 'icon' | 'color'>): FormButton;
-export declare function isFormButton(value: any): value is FormButton;

package/form/form-button.js

@@ -1,49 +0,0 @@
-import { computed, signal } from '../signals/api.js';
-import { FormHeaderFooterElement } from './form-header-footer-element.js';
-import { bindReactiveOption } from './utils.js';
-export class FormButton extends FormHeaderFooterElement {
-    #label = signal(null);
-    #type = signal('button');
-    #disabled = signal(false);
-    #design = signal('flat');
-    #color = signal('accent');
-    #icon = signal(null);
-    #iconLocation = signal('before');
-    #iconSize = signal('normal');
-    handler;
-    label = this.#label.asReadonly();
-    type = this.#type.asReadonly();
-    disabled = this.#disabled.asReadonly();
-    style = this.#design.asReadonly();
-    color = this.#color.asReadonly();
-    icon = this.#icon.asReadonly();
-    iconLocation = this.#iconLocation.asReadonly();
-    iconSize = this.#iconSize.asReadonly();
-    constructor(options) {
-        super(options);
-        this.handler = options.handler;
-        bindReactiveOption(options.label, this.#label, { defaultValue: null });
-        bindReactiveOption(options.type, this.#type, { defaultValue: 'button' });
-        bindReactiveOption(options.disabled, this.#disabled, { defaultValue: false });
-        bindReactiveOption(options.design, this.#design, { defaultValue: 'flat' });
-        bindReactiveOption(options.color, this.#color, { defaultValue: 'accent' });
-        bindReactiveOption(options.icon, this.#icon, { defaultValue: null });
-        bindReactiveOption(options.iconLocation, this.#iconLocation, { defaultValue: 'before' });
-        bindReactiveOption(options.iconSize, this.#iconSize, { defaultValue: 'normal' });
-    }
-}
-export function formButton(options) {
-    return new FormButton(options);
-}
-export function dialogFormButton(options) {
-    const showError = computed(() => ((options.showErrors ?? true) ? options.dialog.touched() ? options.dialog.invalid() : false : false));
-    return formButton({
-        handler: () => options.dialog.openDialog(),
-        ...options,
-        icon: computed(() => (showError() ? 'warning' : null)),
-        color: computed(() => (showError() ? 'red' : null))
-    });
-}
-export function isFormButton(value) {
-    return (value instanceof FormButton);
-}

package/form/form-container.d.ts

@@ -1,24 +0,0 @@
-import type { OneOrMany, ReactiveValue } from '../types.js';
-import { AbstractControl, type AbstractControlOptions } from './abstract-control.js';
-import type { FormHeaderFooterElement } from './form-header-footer-element.js';
-import type { ClassesOption, ClassesOptions } from './types.js';
-export type FormContainerOptions<T> = AbstractControlOptions<T> & ClassesOptions & {
-    displayLabel?: ReactiveValue<boolean>;
-    displayLine?: ReactiveValue<boolean>;
-    headerContainerClasses?: ReactiveValue<ClassesOption>;
-    footerContainerClasses?: ReactiveValue<ClassesOption>;
-    headerElements?: ReactiveValue<OneOrMany<FormHeaderFooterElement>>;
-    footerElements?: ReactiveValue<OneOrMany<FormHeaderFooterElement>>;
-};
-export declare abstract class FormContainer<T, TRaw> extends AbstractControl<T, TRaw> {
-    #private;
-    readonly displayLabel: import("../signals/api.js").Signal<boolean>;
-    readonly displayLine: import("../signals/api.js").Signal<boolean>;
-    readonly headerElements: import("../signals/api.js").Signal<readonly FormHeaderFooterElement[]>;
-    readonly footerElements: import("../signals/api.js").Signal<readonly FormHeaderFooterElement[]>;
-    readonly headerContainerClasses: import("../signals/api.js").Signal<readonly string[]>;
-    readonly footerContainerClasses: import("../signals/api.js").Signal<readonly string[]>;
-    readonly classes: import("../signals/api.js").Signal<readonly string[]>;
-    constructor(options: FormContainerOptions<T>);
-}
-export declare function isFormContainer(value: any): value is FormContainer<any, any>;

package/form/form-container.js

@@ -1,33 +0,0 @@
-import { signal } from '../signals/api.js';
-import { toArray } from '../utils/array/array.js';
-import { AbstractControl } from './abstract-control.js';
-import { bindReactiveOption, normalizeClassesOption } from './utils.js';
-export class FormContainer extends AbstractControl {
-    #displayLabel = signal(true);
-    #displayLine = signal(false);
-    #headerElements = signal([]);
-    #footerElements = signal([]);
-    #headerContainerClasses = signal([]);
-    #footerContainerClasses = signal([]);
-    #classes = signal([]);
-    displayLabel = this.#displayLabel.asReadonly();
-    displayLine = this.#displayLine.asReadonly();
-    headerElements = this.#headerElements.asReadonly();
-    footerElements = this.#footerElements.asReadonly();
-    headerContainerClasses = this.#headerContainerClasses.asReadonly();
-    footerContainerClasses = this.#footerContainerClasses.asReadonly();
-    classes = this.#classes.asReadonly();
-    constructor(options) {
-        super(options);
-        bindReactiveOption(options.displayLabel, this.#displayLabel, { defaultValue: true });
-        bindReactiveOption(options.displayLine, this.#displayLine, { defaultValue: false });
-        bindReactiveOption(options.headerElements, (elements) => this.#headerElements.set(toArray(elements)), { defaultValue: [] });
-        bindReactiveOption(options.footerElements, (elements) => this.#footerElements.set(toArray(elements)), { defaultValue: [] });
-        bindReactiveOption(options.headerContainerClasses, (classes) => this.#headerContainerClasses.set(normalizeClassesOption(classes)));
-        bindReactiveOption(options.footerContainerClasses, (classes) => this.#footerContainerClasses.set(normalizeClassesOption(classes)));
-        bindReactiveOption(options.classes, (classes) => this.#classes.set(normalizeClassesOption(classes)));
-    }
-}
-export function isFormContainer(value) {
-    return (value instanceof FormContainer);
-}

package/form/form-control.d.ts

@@ -1,45 +0,0 @@
-import { type Signal } from '../signals/api.js';
-import type { ReactiveValue } from '../types.js';
-import { AbstractControl, type AbstractControlOptions } from './abstract-control.js';
-import type { ClassesOptions, DynamicTextOption } from './types.js';
-import { type FormValidatorError } from './validators/index.js';
-export type InitialValue<T> = T | null;
-export type InitialValueOption<T> = {
-    initialValue: T;
-};
-export type FormControlOptions<T = any> = AbstractControlOptions<T> & ClassesOptions & {
-    initialValue?: ReactiveValue<T>;
-    required?: ReactiveValue<boolean | null>;
-    suffix?: ReactiveValue<DynamicTextOption>;
-    hint?: ReactiveValue<DynamicTextOption>;
-};
-export type FormControlValueType<T extends FormControl<any>> = T extends FormControl<infer U> ? U : never;
-export declare abstract class FormControl<T, U = any> extends AbstractControl<T, T> {
-    #private;
-    readonly initialValue: Signal<T>;
-    readonly rawValue: Signal<T>;
-    /** Value for rendering including formatting etc. */
-    readonly inputValue: Signal<U | null>;
-    /** Same as {@link rawValue} for simple controls */
-    readonly value: Signal<T>;
-    readonly dirty: Signal<boolean>;
-    readonly touched: Signal<boolean>;
-    readonly required: Signal<boolean>;
-    readonly suffix: Signal<DynamicTextOption>;
-    readonly hint: Signal<DynamicTextOption>;
-    readonly classes: Signal<string[]>;
-    readonly errors: Signal<FormValidatorError[]>;
-    readonly errorDebug: Signal<FormValidatorError[] | null>;
-    constructor(initialValue: T, options: FormControlOptions<T>);
-    setInitialValue(value: T): void;
-    setInputValue(value: U | null): void;
-    setValue(value: T | null): void;
-    reset(): void;
-    markAsDirty(): void;
-    markAsTouched(): void;
-    formatInputValue(): void;
-    parseRawValue?(value: T | null): T | null;
-    abstract parseInputValue(value: U | null): T | null;
-    abstract formatRawValue(value: T | null): U;
-}
-export declare function isFormControl(value: any): value is FormControl<any>;

package/form/form-control.js

@@ -1,92 +0,0 @@
-import { computed, signal, untracked } from '../signals/api.js';
-import { switchAll } from '../signals/index.js';
-import { isDefined, isNotNull } from '../utils/type-guards.js';
-import { AbstractControl, computedInternalValidators, ignoreFormValue } from './abstract-control.js';
-import { bindReactiveOption, normalizeClassesOption } from './utils.js';
-import { requiredValidator } from './validators/index.js';
-export class FormControl extends AbstractControl {
-    #initialValue = signal(null);
-    #rawValue = signal(null);
-    #inputValue = signal(null);
-    #dirty = signal(false);
-    #touched = signal(false);
-    #required = signal(false);
-    #suffix = signal(null);
-    #hint = signal(null);
-    #classes = signal([]);
-    initialValue = this.#initialValue.asReadonly();
-    rawValue = computed(() => this.#rawValue() ?? this.initialValue());
-    /** Value for rendering including formatting etc. */
-    inputValue = this.#inputValue.asReadonly();
-    /** Same as {@link rawValue} for simple controls */
-    value = this.rawValue;
-    dirty = this.#dirty.asReadonly();
-    touched = this.#touched.asReadonly();
-    required = this.#required.asReadonly();
-    suffix = this.#suffix.asReadonly();
-    hint = this.#hint.asReadonly();
-    classes = this.#classes.asReadonly();
-    errors = switchAll(() => {
-        const validations = this.validators().map((validator) => validator(this));
-        return computed(() => validations.map((validation) => validation()).filter(isNotNull));
-    });
-    errorDebug = computed(() => this.valid() ? null : this.errors());
-    constructor(initialValue, options) {
-        super(options);
-        this.#initialValue.set(initialValue);
-        this.setValue(initialValue);
-        bindReactiveOption(options.initialValue ?? initialValue, (value) => this.setInitialValue(value));
-        bindReactiveOption(options.required, this.#required, { defaultValue: false });
-        bindReactiveOption(options.suffix, this.#suffix, { defaultValue: null });
-        bindReactiveOption(options.hint, this.#hint, { defaultValue: null });
-        bindReactiveOption(options.classes, (value) => this.#classes.set(normalizeClassesOption(value)));
-        this.registerValidators(computedInternalValidators(() => [
-            this.required() ? requiredValidator() : null
-        ]));
-    }
-    setInitialValue(value) {
-        const updateInputValue = untracked(this.value) == untracked(this.initialValue);
-        this.#initialValue.set(value);
-        if (updateInputValue) {
-            this.#inputValue.set(this.formatRawValue(value));
-        }
-    }
-    setInputValue(value) {
-        if (value == untracked(this.#inputValue)) {
-            return;
-        }
-        const parsed = this.parseInputValue(value);
-        this.#inputValue.set(value);
-        this.#rawValue.set(parsed);
-    }
-    setValue(value) {
-        if (value == ignoreFormValue) {
-            return;
-        }
-        const newRawValue = (value == this.initialValue()) ? null : value;
-        if (newRawValue === untracked(this.#rawValue)) {
-            return;
-        }
-        const parsed = isDefined(this.parseRawValue) ? this.parseRawValue(newRawValue) : newRawValue; // eslint-disable-line @typescript-eslint/unbound-method
-        this.#rawValue.set(parsed);
-        this.formatInputValue();
-    }
-    reset() {
-        this.setValue(null);
-        this.#dirty.set(false);
-        this.#touched.set(false);
-    }
-    markAsDirty() {
-        this.#dirty.set(true);
-    }
-    markAsTouched() {
-        this.#touched.set(true);
-    }
-    formatInputValue() {
-        const formatted = this.formatRawValue(untracked(this.value));
-        this.#inputValue.set(formatted);
-    }
-}
-export function isFormControl(value) {
-    return (value instanceof FormControl);
-}

package/form/form-dialog.d.ts

@@ -1,22 +0,0 @@
-import type { Signal } from '../signals/api.js';
-import type { ReactiveValue } from '../types.js';
-import type { AbstractControl, AbstractControlRawValueType, AbstractControlValueType } from './abstract-control.js';
-import { FormWrapper, type FormWrapperOptions } from './form-wrapper.js';
-import type { DynamicTextOption } from './types.js';
-export type FormDialogOptions<T, C extends AbstractControl<T>> = FormWrapperOptions<T, C> & {
-    header?: ReactiveValue<DynamicTextOption>;
-    displayType?: ReactiveValue<FormDialogDisplayType>;
-};
-export type FormDialogDisplayType = 'none' | 'button';
-export type FormDialogByControl<C extends AbstractControl> = FormDialog<AbstractControlValueType<C>, AbstractControlRawValueType<C>, C>;
-export declare class FormDialog<T = any, TRaw = any, C extends AbstractControl<T, TRaw> = AbstractControl<T, TRaw>, DialogHandle = any> extends FormWrapper<T, TRaw, C> {
-    #private;
-    readonly displayType: Signal<FormDialogDisplayType>;
-    readonly header: Signal<DynamicTextOption>;
-    readonly openDialog$: import("rxjs").Observable<void>;
-    dialogHandle: DialogHandle | null;
-    constructor(options: FormDialogOptions<T, C>);
-    openDialog(): void;
-}
-export declare function formDialog<C extends AbstractControl>(options: FormDialogOptions<AbstractControlRawValueType<C>, C>): FormDialog<AbstractControlValueType<C>, AbstractControlRawValueType<C>, C>;
-export declare function isFormDialog(value: any): value is FormDialog;

package/form/form-dialog.js

@@ -1,24 +0,0 @@
-import { Subject } from 'rxjs';
-import { FormWrapper } from './form-wrapper.js';
-import { reactiveOptionToSignal } from './utils.js';
-export class FormDialog extends FormWrapper {
-    #openDialogSubject = new Subject();
-    displayType;
-    header;
-    openDialog$ = this.#openDialogSubject.asObservable();
-    dialogHandle = null;
-    constructor(options) {
-        super(options);
-        this.displayType = reactiveOptionToSignal(options.displayType ?? 'none', { initialValue: 'none' });
-        this.header = reactiveOptionToSignal(options.header ?? null, { initialValue: null });
-    }
-    openDialog() {
-        this.#openDialogSubject.next();
-    }
-}
-export function formDialog(options) {
-    return new FormDialog(options);
-}
-export function isFormDialog(value) {
-    return (value instanceof FormDialog);
-}

package/form/form-element.d.ts

@@ -1,7 +0,0 @@
-export type FormElementOptions = {
-    id?: string;
-};
-export declare abstract class FormElement {
-    readonly id: string;
-    constructor(options?: FormElementOptions);
-}

package/form/form-element.js

@@ -1,6 +0,0 @@
-export class FormElement {
-    id;
-    constructor(options) {
-        this.id = options?.id ?? crypto.randomUUID();
-    }
-}

package/form/form-group.d.ts

@@ -1,70 +0,0 @@
-import type { JsonPath } from '../json-path/json-path.js';
-import { type Signal } from '../signals/index.js';
-import type { ReactiveValue, Record } 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 { FormValue, RawFormValue } from './types.js';
-import type { FormValidatorError } from './validators/form.validator.js';
-type FormGroupDisplayType = 'simple' | 'block' | 'stepper' | 'tabs';
-type FormGroupStepperOrientiation = 'horizontal' | 'vertical';
-export type FromGroupControls<T extends Record> = {
-    [P in keyof T]: AbstractControl<T[P]>;
-};
-export type FormGroupOptions<T extends Record = Record, C extends FromGroupControls<T> = FromGroupControls<T>> = FormContainerOptions<Partial<T>> & {
-    displayType?: ReactiveValue<FormGroupDisplayType>;
-    stepperOrientation?: ReactiveValue<FormGroupStepperOrientiation>;
-    children: C;
-};
-export type FormGroupChildren<T extends FormGroup> = T extends FormGroup<any, infer C> ? C : never;
-export type FormGroupChild<T extends FormGroup, K extends keyof FormGroupChildren<T>> = FormGroupChildren<T>[K];
-export type FormGroupChildValue<T extends FormGroup, K extends keyof AbstractControlRawValueType<T>> = AbstractControlValueType<T>[K];
-export type FormGroupChildRawValue<T extends FormGroup, K extends keyof AbstractControlRawValueType<T>> = AbstractControlRawValueType<T>[K];
-export type FormGroupRawValueType<C extends FromGroupControls<Record>> = {
-    [P in keyof C]: AbstractControlRawValueType<C[P]>;
-};
-export type FormGroupByControls<C extends FromGroupControls<Record> = FromGroupControls<Record>> = FormGroup<FormGroupRawValueType<C>, C>;
-export declare class FormGroup<T extends Record = Record, C extends FromGroupControls<T> = FromGroupControls<T>> extends FormContainer<Partial<T>, T> implements Iterable<[keyof C, C[keyof C]]> {
-    #private;
-    protected readonly internalValidators: null;
-    readonly displayType: Signal<FormGroupDisplayType>;
-    readonly stepperOrientation: Signal<FormGroupStepperOrientiation>;
-    readonly children: Signal<Readonly<C>>;
-    readonly childrenEntries: Signal<[keyof C, Readonly<C>[keyof C]][]>;
-    readonly childrenValues: Signal<Readonly<C>[keyof C][]>;
-    readonly enabledChildrenEntries: Signal<[keyof C, Readonly<C>[keyof C]][]>;
-    readonly enabledChildrenValues: Signal<Readonly<C>[keyof C][]>;
-    /**
-     * Raw values of all children whether disabled or not
-     */
-    readonly rawValue: Signal<T>;
-    /**
-     * If enabled: values of all enabled children
-     * if disabled: values of all children whether disabled or not (same as {@link rawValue})
-     */
-    readonly value: Signal<Partial<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[];
-    } & { [K in import("../types.js").Cast<keyof C, PropertyKey>]: import("../types.js").Fallback<Extract<readonly [keyof C, any], readonly [K, any]>[1], any>; }) | null>;
-    constructor(options: FormGroupOptions<T, C>);
-    setParent(parent: AbstractControlParent, force?: boolean): void;
-    setParent(parent: null): void;
-    getChildPath(child: AbstractControl): Signal<JsonPath>;
-    reset(): void;
-    get<K extends keyof C>(key: K): C[K];
-    getValue<K extends keyof C>(key: K): FormValue<C[K]>;
-    getRawValue<K extends keyof C>(key: K): RawFormValue<C[K]>;
-    patchValue(values: Partial<T>): void;
-    setValue(values: Partial<T>): void;
-    markAsDirty({ onlySelf }?: MarkOptions): void;
-    markAsTouched({ onlySelf }?: MarkOptions): void;
-    [Symbol.iterator](): Iterator<[keyof C, C[keyof C]]>;
-    private updateParents;
-}
-export declare function formGroup<C extends FromGroupControls<Record> = FromGroupControls<Record>>(options: FormGroupOptions<FormGroupRawValueType<C>, C>): FormGroup<FormGroupRawValueType<C>, C>;
-export declare function isFormGroup(value: any): value is FormGroup;
-export {};

package/form/form-group.js

@@ -1,134 +0,0 @@
-import { computed, signal, switchAll } from '../signals/index.js';
-import { fromEntries, hasOwnProperty, objectEntries } from '../utils/object/object.js';
-import { isDefined, isNotNull } from '../utils/type-guards.js';
-import { ignoreFormValue } from './abstract-control.js';
-import { FormContainer } from './form-container.js';
-import { reactiveOptionToSignal } from './utils.js';
-export class FormGroup extends FormContainer {
-    #children = signal({});
-    #selfTouched = signal(false);
-    #selfDirty = signal(false);
-    internalValidators = null;
-    displayType;
-    stepperOrientation;
-    children = this.#children.asReadonly();
-    childrenEntries = computed(() => objectEntries(this.children()));
-    childrenValues = computed(() => this.childrenEntries().map(([_, child]) => child));
-    enabledChildrenEntries = computed(() => this.childrenEntries().filter(([_, child]) => child.enabled()));
-    enabledChildrenValues = computed(() => this.enabledChildrenEntries().map(([_, child]) => child));
-    /**
-     * Raw values of all children whether disabled or not
-     */
-    rawValue = computed(() => fromEntries(this.childrenEntries().map(([key, child]) => [key, child.rawValue()]))); // eslint-disable-line @typescript-eslint/no-unsafe-return
-    /**
-     * If enabled: values of all enabled children
-     * if disabled: values of all children whether disabled or not (same as {@link rawValue})
-     */
-    value = computed(() => (this.disabled()
-        ? this.rawValue()
-        : fromEntries(this.childrenEntries()
-            .filter(([_, child]) => child.enabled())
-            .map(([key, child]) => [key, child.value()]))));
-    dirty = computed(() => this.#selfDirty() || this.enabledChildrenValues().some((child) => child.dirty()));
-    touched = computed(() => this.#selfTouched() || this.enabledChildrenValues().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.enabledChildrenValues().flatMap((child) => child.errors()));
-    errors = computed(() => [
-        ...this.localErrors(),
-        ...this.childrenErrors()
-    ]);
-    errorDebug = computed(() => this.valid()
-        ? null
-        : ({
-            _self: this.localErrors(),
-            ...fromEntries(this.childrenEntries().map(([key, child]) => [key, child.errorDebug()]).filter(([, errorDebug]) => isNotNull(errorDebug)))
-        }));
-    constructor(options) {
-        super(options);
-        this.displayType = reactiveOptionToSignal(options.displayType ?? 'simple', { initialValue: 'simple' });
-        this.stepperOrientation = reactiveOptionToSignal(options.stepperOrientation ?? 'vertical', { initialValue: 'vertical' });
-        this.#children.set(options.children);
-        this.updateParents();
-    }
-    setParent(parent, force) {
-        super.setParent(parent, force);
-        this.updateParents(true);
-    }
-    getChildPath(child) {
-        return computed(() => {
-            const key = this.childrenEntries().find(([_, _child]) => child == _child)?.[0] ?? '_CHILD_NOT_FOUND_';
-            return this.path().add(key);
-        });
-    }
-    reset() {
-        for (const child of this.childrenValues()) {
-            child.reset();
-        }
-    }
-    get(key) {
-        return this.children()[key];
-    }
-    getValue(key) {
-        return this.get(key).value(); // eslint-disable-line @typescript-eslint/no-unsafe-return
-    }
-    getRawValue(key) {
-        return this.get(key).rawValue(); // eslint-disable-line @typescript-eslint/no-unsafe-return
-    }
-    patchValue(values) {
-        const children = this.children();
-        for (const [key, value] of objectEntries(values)) {
-            if (isDefined(value) && hasOwnProperty(children, key)) {
-                children[key].setValue(value);
-            }
-        }
-    }
-    setValue(values) {
-        if (values == ignoreFormValue) {
-            return;
-        }
-        for (const [key, child] of this.childrenEntries()) {
-            const value = values[key];
-            if (isDefined(value)) {
-                child.setValue(value);
-            }
-            else {
-                child.reset();
-            }
-        }
-    }
-    markAsDirty({ onlySelf = false } = {}) {
-        this.#selfDirty.set(true);
-        if (onlySelf) {
-            return;
-        }
-        for (const child of this.childrenValues()) {
-            child.markAsDirty();
-        }
-    }
-    markAsTouched({ onlySelf = false } = {}) {
-        this.#selfTouched.set(true);
-        if (onlySelf) {
-            return;
-        }
-        for (const child of this.childrenValues()) {
-            child.markAsTouched();
-        }
-    }
-    *[Symbol.iterator]() {
-        yield* this.childrenEntries();
-    }
-    updateParents(force) {
-        for (const child of this.childrenValues()) {
-            child.setParent(this, force);
-        }
-    }
-}
-export function formGroup(options) {
-    return new FormGroup(options);
-}
-export function isFormGroup(value) {
-    return (value instanceof FormGroup);
-}

package/form/form-header-footer-element.d.ts

@@ -1,14 +0,0 @@
-import type { ReactiveValue } from '../types.js';
-import { FormElement, type FormElementOptions } from './form-element.js';
-import type { ClassesOptions } from './types.js';
-export type FormHeaderFooterElementOptions = FormElementOptions & ClassesOptions & {
-    hide?: ReactiveValue<boolean | null>;
-    show?: ReactiveValue<boolean | null>;
-};
-export declare abstract class FormHeaderFooterElement extends FormElement {
-    #private;
-    readonly hide: import("../signals/api.js").Signal<boolean>;
-    readonly show: import("../signals/api.js").Signal<boolean>;
-    readonly classes: import("../signals/api.js").Signal<string[]>;
-    constructor(options: FormHeaderFooterElementOptions);
-}

package/form/form-header-footer-element.js

@@ -1,20 +0,0 @@
-import { computed, signal } from '../signals/api.js';
-import { isDefined } from '../utils/type-guards.js';
-import { FormElement } from './form-element.js';
-import { bindReactiveOption, normalizeClassesOption } from './utils.js';
-export class FormHeaderFooterElement extends FormElement {
-    #hide = signal(false);
-    #classes = signal([]);
-    hide = this.#hide.asReadonly();
-    show = computed(() => !this.hide());
-    classes = this.#classes.asReadonly();
-    constructor(options) {
-        super(options);
-        if (isDefined(options.show) && isDefined(options.hide)) {
-            throw new Error('Either enabled or disabled can be set but not both.');
-        }
-        bindReactiveOption(options.hide, (hide) => this.#hide.set(hide ?? false));
-        bindReactiveOption(options.show, (show) => this.#hide.set(!(show ?? true)));
-        bindReactiveOption(options.classes, (value) => this.#classes.set(normalizeClassesOption(value)));
-    }
-}

package/form/form-portal.d.ts

@@ -1,10 +0,0 @@
-import type { TypedOmit } from '../types.js';
-import { type AbstractControl, type AbstractControlRawValueType, type AbstractControlValueType } from './abstract-control.js';
-import { FormWrapper, type FormWrapperOptions } from './form-wrapper.js';
-export type FormPortalOptions<T, C extends AbstractControl<T>> = FormWrapperOptions<T, C>;
-export type FormPortalByControl<C extends AbstractControl> = FormPortal<AbstractControlValueType<C>, AbstractControlRawValueType<C>, C>;
-export declare class FormPortal<T = any, TRaw = any, C extends AbstractControl<T, TRaw> = AbstractControl<T, TRaw>> extends FormWrapper<T, TRaw, C> {
-}
-export declare function formPortal<C extends AbstractControl>(control: C, options?: TypedOmit<FormPortalOptions<AbstractControlRawValueType<C>, C>, 'element'>): FormPortal<AbstractControlValueType<C>, AbstractControlRawValueType<C>, C>;
-export declare function formPortal<C extends AbstractControl>(options: FormPortalOptions<AbstractControlRawValueType<C>, C>): FormPortal<AbstractControlValueType<C>, AbstractControlRawValueType<C>, C>;
-export declare function isFormPortal(value: any): value is FormPortal;

package/form/form-portal.js

@@ -1,13 +0,0 @@
-import { isAbstractControl } from './abstract-control.js';
-import { FormWrapper } from './form-wrapper.js';
-export class FormPortal extends FormWrapper {
-}
-export function formPortal(controlOrOptions, optionsOrNothing) {
-    if (isAbstractControl(controlOrOptions)) {
-        return new FormPortal({ ...optionsOrNothing, element: controlOrOptions });
-    }
-    return new FormPortal({ ...controlOrOptions });
-}
-export function isFormPortal(value) {
-    return (value instanceof FormPortal);
-}

package/form/form-text.d.ts

@@ -1,13 +0,0 @@
-import type { Signal } from '../signals/api.js';
-import type { ReactiveValue } from '../types.js';
-import { FormHeaderFooterElement, type FormHeaderFooterElementOptions } from './form-header-footer-element.js';
-import type { DynamicTextOption } from './types.js';
-export type FormTextOptions = FormHeaderFooterElementOptions & {
-    text: ReactiveValue<DynamicTextOption>;
-};
-export declare class FormText extends FormHeaderFooterElement {
-    readonly text: Signal<DynamicTextOption>;
-    constructor(options: FormTextOptions);
-}
-export declare function formText(options: FormTextOptions): FormText;
-export declare function isFormText(value: any): value is FormText;

package/form/form-text.js

@@ -1,15 +0,0 @@
-import { FormHeaderFooterElement } from './form-header-footer-element.js';
-import { reactiveOptionToSignal } from './utils.js';
-export class FormText extends FormHeaderFooterElement {
-    text;
-    constructor(options) {
-        super(options);
-        this.text = reactiveOptionToSignal(options.text, { initialValue: '[MISSING TEXT]' });
-    }
-}
-export function formText(options) {
-    return new FormText(options);
-}
-export function isFormText(value) {
-    return (value instanceof FormText);
-}