@tstdl/base 0.91.40 → 0.91.42

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);
-}

package/form/form-wrapper.d.ts

@@ -1,40 +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 { type FormContainerOptions, FormContainer } from './form-container.js';
-export type FormWrapperOptions<T, C extends AbstractControl<T>> = FormContainerOptions<T> & {
-    element: C;
-    forwardWrites?: ReactiveValue<boolean>;
-    forwardErrors?: ReactiveValue<boolean>;
-};
-export type FormWrapperByControl<C extends AbstractControl> = FormWrapper<AbstractControlValueType<C>, AbstractControlRawValueType<C>, C>;
-export declare abstract class FormWrapper<T = any, TRaw = any, C extends AbstractControl<T, TRaw> = AbstractControl<T, TRaw>> extends FormContainer<T, TRaw> {
-    #private;
-    protected readonly internalValidators: null;
-    readonly element: Signal<C>;
-    readonly forwardWrites: Signal<boolean>;
-    readonly forwardErrors: Signal<boolean>;
-    errors: Signal<import("./index.js").FormValidatorError[]>;
-    valid: Signal<boolean>;
-    invalid: Signal<boolean>;
-    disabled: Signal<boolean>;
-    enabled: Signal<boolean>;
-    untouched: Signal<boolean>;
-    pristine: Signal<boolean>;
-    rawValue: Signal<TRaw>;
-    value: Signal<T>;
-    dirty: Signal<boolean>;
-    touched: Signal<boolean>;
-    errorDebug: Signal<{
-        wrapped: any;
-    }>;
-    constructor(options: FormWrapperOptions<T, C>);
-    setElement(element: C): void;
-    setReadonly(readonly: boolean): void;
-    setDisabled(disabled: boolean): void;
-    setValue(value: T): void;
-    reset(): void;
-    markAsTouched(): void;
-    markAsDirty(): void;
-}
-export declare function isFormWrapper(value: any): value is FormWrapper<any, any, any>;

package/form/form-wrapper.js

@@ -1,64 +0,0 @@
-import { computed, signal, untracked } from '../signals/api.js';
-import { FormContainer } from './form-container.js';
-import { reactiveOptionToSignal } from './utils.js';
-export class FormWrapper extends FormContainer {
-    #element = signal(null);
-    internalValidators = null;
-    element = this.#element.asReadonly();
-    forwardWrites;
-    forwardErrors;
-    errors = computed(() => this.forwardErrors() ? this.element().errors() : []);
-    valid = computed(() => this.forwardErrors() ? this.element().valid() : true);
-    invalid = computed(() => this.forwardErrors() ? this.element().invalid() : false);
-    disabled = computed(() => this.element().disabled());
-    enabled = computed(() => this.element().enabled());
-    untouched = computed(() => this.element().untouched());
-    pristine = computed(() => this.element().pristine());
-    rawValue = computed(() => this.element().rawValue());
-    value = computed(() => this.element().value());
-    dirty = computed(() => this.element().dirty());
-    touched = computed(() => this.element().touched());
-    errorDebug = computed(() => ({ wrapped: this.element().errorDebug() }));
-    constructor(options) {
-        super(options);
-        this.forwardWrites = reactiveOptionToSignal(options.forwardWrites ?? true, { requireSync: true });
-        this.forwardErrors = reactiveOptionToSignal(options.forwardErrors ?? true, { requireSync: true });
-        this.setElement(options.element);
-    }
-    setElement(element) {
-        this.#element.set(element);
-    }
-    setReadonly(readonly) {
-        if (untracked(this.forwardWrites)) {
-            untracked(this.element).setReadonly(readonly);
-        }
-    }
-    setDisabled(disabled) {
-        if (untracked(this.forwardWrites)) {
-            untracked(this.element).setDisabled(disabled);
-        }
-    }
-    setValue(value) {
-        if (untracked(this.forwardWrites)) {
-            untracked(this.element).setValue(value);
-        }
-    }
-    reset() {
-        if (untracked(this.forwardWrites)) {
-            untracked(this.element).reset();
-        }
-    }
-    markAsTouched() {
-        if (untracked(this.forwardWrites)) {
-            untracked(this.element).markAsTouched();
-        }
-    }
-    markAsDirty() {
-        if (untracked(this.forwardWrites)) {
-            untracked(this.element).markAsDirty();
-        }
-    }
-}
-export function isFormWrapper(value) {
-    return (value instanceof FormWrapper);
-}

package/form/index.d.ts

@@ -1,15 +0,0 @@
-export * from './abstract-control.js';
-export * from './controls/index.js';
-export * from './form-array.js';
-export * from './form-button.js';
-export * from './form-control.js';
-export * from './form-dialog.js';
-export * from './form-element.js';
-export * from './form-group.js';
-export * from './form-header-footer-element.js';
-export * from './form-portal.js';
-export * from './form-text.js';
-export * from './form-wrapper.js';
-export * from './types.js';
-export * from './utils.js';
-export * from './validators/index.js';

package/form/index.js

@@ -1,15 +0,0 @@
-export * from './abstract-control.js';
-export * from './controls/index.js';
-export * from './form-array.js';
-export * from './form-button.js';
-export * from './form-control.js';
-export * from './form-dialog.js';
-export * from './form-element.js';
-export * from './form-group.js';
-export * from './form-header-footer-element.js';
-export * from './form-portal.js';
-export * from './form-text.js';
-export * from './form-wrapper.js';
-export * from './types.js';
-export * from './utils.js';
-export * from './validators/index.js';

package/form/localization.d.ts

@@ -1,49 +0,0 @@
-import { type Localization, type LocalizeItem } from '../text/localization.service.js';
-export type TstdlFormLocalization = Localization<{
-    tstdl: {
-        validation: {
-            required: LocalizeItem;
-            unique: LocalizeItem;
-            pattern: LocalizeItem;
-            maxLength: LocalizeItem<{
-                maxLength: number;
-            }>;
-            time: LocalizeItem<{
-                minimum?: number;
-                maximum?: number;
-            }>;
-            date: LocalizeItem<{
-                minimum?: Date | number;
-                maximum?: Date | number;
-            }>;
-            number: LocalizeItem<{
-                minimum?: number;
-                maximum?: number;
-            }>;
-        };
-    };
-}>;
-export declare const tstdlFormLocalizationKeys: import("../text/localization.service.js").ProxyLocalizationKeys<{
-    validation: {
-        required: LocalizeItem;
-        unique: LocalizeItem;
-        pattern: LocalizeItem;
-        maxLength: LocalizeItem<{
-            maxLength: number;
-        }>;
-        time: LocalizeItem<{
-            minimum?: number;
-            maximum?: number;
-        }>;
-        date: LocalizeItem<{
-            minimum?: Date | number;
-            maximum?: Date | number;
-        }>;
-        number: LocalizeItem<{
-            minimum?: number;
-            maximum?: number;
-        }>;
-    };
-}>;
-export declare const germanTstdlFormLocalization: TstdlFormLocalization;
-export declare const englishTstdlFormLocalization: TstdlFormLocalization;

package/form/localization.js

@@ -1,56 +0,0 @@
-import { formatDateShort, formatTimeShort } from '../formats.js';
-import { getLocalizationKeys } from '../text/localization.service.js';
-import { isDefined } from '../utils/type-guards.js';
-export const tstdlFormLocalizationKeys = getLocalizationKeys().tstdl;
-export const germanTstdlFormLocalization = {
-    language: { code: 'de', name: 'Deutsch' },
-    keys: {
-        tstdl: {
-            validation: {
-                required: 'Angabe erforderlich',
-                unique: 'Wert darf nur einmal vorkommen',
-                pattern: 'Ungültiges Format',
-                maxLength: ({ maxLength }) => `Maximallänge von ${maxLength} überschritten`,
-                time: ({ minimum, maximum }) => ((isDefined(minimum) && isDefined(maximum)) ? `Uhrzeit muss zwischen ${formatTimeShort(minimum)} und ${formatTimeShort(maximum)} liegen`
-                    : isDefined(minimum) ? `Uhrzeit muss nach ${formatTimeShort(minimum)} liegen`
-                        : isDefined(maximum) ? `Uhrzeit muss vor ${formatTimeShort(maximum)} liegen`
-                            : 'Ungültige Uhrzeit'),
-                date: ({ minimum, maximum }) => ((isDefined(minimum) && isDefined(maximum)) ? `Datum muss zwischen ${formatDateShort(minimum)} und ${formatDateShort(maximum)} liegen`
-                    : isDefined(minimum) ? `Datum muss nach ${formatDateShort(minimum)} liegen`
-                        : isDefined(maximum) ? `Datum muss vor ${formatDateShort(maximum)} liegen`
-                            : 'Ungültiges Datum'),
-                number: ({ minimum, maximum }) => ((isDefined(minimum) && isDefined(maximum)) ? `Wert muss zwischen ${minimum} und ${maximum} liegen`
-                    : isDefined(minimum) ? `Wert muss größer/gleich ${minimum} sein`
-                        : isDefined(maximum) ? `Wert muss kleiner/gleich ${maximum} sein`
-                            : 'Ungültiger Wert')
-            }
-        }
-    },
-    enums: []
-};
-export const englishTstdlFormLocalization = {
-    language: { code: 'en', name: 'English' },
-    keys: {
-        tstdl: {
-            validation: {
-                required: 'Input required',
-                unique: 'Value must be unique',
-                pattern: 'Invalid format',
-                maxLength: ({ maxLength }) => `Maxmimum length of ${maxLength} exceeded`,
-                time: ({ minimum, maximum }) => ((isDefined(minimum) && isDefined(maximum)) ? `Time must be between ${formatTimeShort(minimum)} and ${formatTimeShort(maximum)}`
-                    : isDefined(minimum) ? `Time must be after ${formatTimeShort(minimum)}`
-                        : isDefined(maximum) ? `Time must be before ${formatTimeShort(maximum)}`
-                            : 'Invalid time'),
-                date: ({ minimum, maximum }) => ((isDefined(minimum) && isDefined(maximum)) ? `Date must be between ${formatDateShort(minimum)} and ${formatDateShort(maximum)}`
-                    : isDefined(minimum) ? `Date must be after ${formatDateShort(minimum)}`
-                        : isDefined(maximum) ? `Date must be before ${formatDateShort(maximum)}`
-                            : 'Invalid date'),
-                number: ({ minimum, maximum }) => ((isDefined(minimum) && isDefined(maximum)) ? `Value must be between ${minimum} and ${maximum}`
-                    : isDefined(minimum) ? `Value must be at least ${minimum}`
-                        : isDefined(maximum) ? `Value must be at most ${maximum}`
-                            : 'Invalid value')
-            }
-        }
-    },
-    enums: []
-};

package/form/types.d.ts

@@ -1,11 +0,0 @@
-import type { LocalizableText } from '../text/localizable-text.model.js';
-import type { ReactiveValue } from '../types.js';
-import type { AbstractControl, AbstractControlRawValueType, AbstractControlValueType } from './abstract-control.js';
-export type FormControlRemoveHandler<C extends AbstractControl = AbstractControl> = (control: C) => boolean | Promise<boolean>;
-export type FormValue<T extends AbstractControl> = AbstractControlValueType<T>;
-export type RawFormValue<T extends AbstractControl> = AbstractControlRawValueType<T>;
-export type DynamicTextOption = LocalizableText | null;
-export type ClassesOption = string | string[] | null;
-export type ClassesOptions = {
-    classes?: ReactiveValue<ClassesOption>;
-};

package/form/types.js

@@ -1 +0,0 @@
-export {};

package/form/utils.d.ts

@@ -1,38 +0,0 @@
-import { type Signal } from '../signals/index.js';
-import { LocalizationService } from '../text/localization.service.js';
-import type { EnumerationObject, FilledReadonlyArray, ReactiveValue } from '../types.js';
-import { type ReactiveValueToSignalOptions } from '../utils/reactive-value-to-signal.js';
-export type EnumFormItem<T> = {
-    label: Signal<string>;
-    value: T;
-};
-export type BindReactiveOptionOptions<D> = {
-    defaultValue?: D;
-};
-export type BindReactiveOptionTarget<T> = (Signal<T> & {
-    set: (value: T) => void;
-}) | ((value: T) => void);
-export declare function enumAsItems<T extends EnumerationObject>(enumeration: T, allowedValues?: FilledReadonlyArray<T[keyof T]>, localizationService?: LocalizationService): EnumFormItem<T[keyof T]>[];
-export declare function nullToUndefinedSignal<T>(source: Signal<T | null>): Signal<T | undefined>;
-export declare function reactiveOptionToSignal<T>(source: ReactiveValue<T>): Signal<T | undefined>;
-export declare function reactiveOptionToSignal<T>(source: ReactiveValue<T>, options: ReactiveValueToSignalOptions<T | undefined> & {
-    initialValue?: undefined;
-    requireSync?: false;
-}): Signal<T | undefined>;
-export declare function reactiveOptionToSignal<T>(source: ReactiveValue<T>, options: ReactiveValueToSignalOptions<T | null> & {
-    initialValue?: null;
-    requireSync?: false;
-}): Signal<T | null>;
-export declare function reactiveOptionToSignal<T>(source: ReactiveValue<T>, options: ReactiveValueToSignalOptions<T> & {
-    initialValue?: undefined;
-    requireSync: true;
-}): Signal<T>;
-export declare function reactiveOptionToSignal<T, const I>(source: ReactiveValue<T>, options: ReactiveValueToSignalOptions<T | I> & {
-    initialValue: I;
-    requireSync?: false;
-}): Signal<T | I>;
-export declare function bindReactiveOption<T>(option: ReactiveValue<T> | undefined, target: BindReactiveOptionTarget<T>): void;
-export declare function bindReactiveOption<T>(option: ReactiveValue<T | null | undefined>, target: BindReactiveOptionTarget<T>, options: BindReactiveOptionOptions<T> & {
-    defaultValue: T;
-}): void;
-export declare function normalizeClassesOption(classes: string | string[] | null): string[];

package/form/utils.js

@@ -1,47 +0,0 @@
-import { inject } from '../injector/inject.js';
-import { computed, effect, isSignal, untracked } from '../signals/index.js';
-import { LocalizationService } from '../text/localization.service.js';
-import { enumValues } from '../utils/enum.js';
-import { hasOwnProperty } from '../utils/object/object.js';
-import { reactiveValueToSignal } from '../utils/reactive-value-to-signal.js';
-import { isNull, isNullOrUndefined, isString, isUndefined } from '../utils/type-guards.js';
-export function enumAsItems(enumeration, allowedValues, localizationService = inject(LocalizationService)) {
-    return enumValues(enumeration)
-        .filter((value) => allowedValues?.includes(value) ?? true)
-        .map((type) => ({ label: localizationService.localizeEnum(enumeration, type), value: type }));
-}
-export function nullToUndefinedSignal(source) {
-    return computed(() => source() ?? undefined);
-}
-export function reactiveOptionToSignal(source, options) {
-    return untracked(() => reactiveValueToSignal(source, options));
-}
-export function bindReactiveOption(option, target, options = {}) {
-    const targetSetValue = isSignal(target)
-        ? (value) => target.set(value)
-        : target;
-    if (isUndefined(option)) {
-        if (hasOwnProperty(options, 'defaultValue')) {
-            targetSetValue(options.defaultValue);
-        }
-        return;
-    }
-    const setValue = (value) => {
-        const defaultedValue = (isNullOrUndefined(value) && hasOwnProperty(options, 'defaultValue')) ? options.defaultValue : value;
-        targetSetValue(defaultedValue);
-    };
-    const optionSignal = reactiveValueToSignal(option);
-    untracked(() => effect(() => setValue(optionSignal()), { allowSignalWrites: true }));
-}
-export function normalizeClassesOption(classes) {
-    if (isNull(classes)) {
-        return [];
-    }
-    if (isString(classes)) {
-        return classes
-            .split(' ')
-            .map((klass) => klass.trim())
-            .filter((klass) => klass.length > 0);
-    }
-    return classes;
-}

package/form/validators/boolean.validator.d.ts

@@ -1,3 +0,0 @@
-import type { DynamicText } from '../../text/dynamic-text.model.js';
-import { type FormValidator } from './form.validator.js';
-export declare function booleanValidator(value: boolean, errorMessage: DynamicText): FormValidator<boolean | null>;

package/form/validators/boolean.validator.js

@@ -1,15 +0,0 @@
-import { computed } from '../../signals/api.js';
-import { isNullOrUndefined } from '../../utils/type-guards.js';
-import { formValidatorError } from './form.validator.js';
-export function booleanValidator(value, errorMessage) {
-    function booleanValidator(control) {
-        return computed(() => {
-            const controlValue = control.value();
-            if (isNullOrUndefined(controlValue) || (controlValue == value)) {
-                return null;
-            }
-            return formValidatorError(control, errorMessage);
-        });
-    }
-    return booleanValidator;
-}

package/form/validators/date.validator.d.ts

@@ -1,4 +0,0 @@
-import type { DynamicText } from '../../text/dynamic-text.model.js';
-import type { ReactiveValue } from '../../types.js';
-import { type FormValidator } from './form.validator.js';
-export declare function dateValidator(minimum: ReactiveValue<Date | number | null | undefined>, maximum: ReactiveValue<Date | number | null | undefined>, errorMessage?: DynamicText): FormValidator<Date | number | null>;

package/form/validators/date.validator.js

@@ -1,26 +0,0 @@
-import { computed } from '../../signals/api.js';
-import { localizationData } from '../../text/localization.service.js';
-import { dateToNumericDate } from '../../utils/date-time.js';
-import { isNullOrUndefined, isNumber } from '../../utils/type-guards.js';
-import { tstdlFormLocalizationKeys } from '../localization.js';
-import { reactiveOptionToSignal } from '../utils.js';
-import { formValidatorError } from './form.validator.js';
-export function dateValidator(minimum, maximum, errorMessage) {
-    const minimumSignal = reactiveOptionToSignal(minimum);
-    const maximumSignal = reactiveOptionToSignal(maximum);
-    function dateValidator(control) {
-        return computed(() => {
-            const value = control.value();
-            const min = minimumSignal();
-            const max = maximumSignal();
-            const valueNumericDate = isNullOrUndefined(value) ? null : isNumber(value) ? value : dateToNumericDate(value);
-            const minNumericDate = isNullOrUndefined(min) ? null : isNumber(min) ? min : dateToNumericDate(min); // eslint-disable-line @typescript-eslint/strict-boolean-expressions
-            const maxNumericDate = isNullOrUndefined(max) ? null : isNumber(max) ? max : dateToNumericDate(max);
-            if (isNullOrUndefined(valueNumericDate) || ((isNullOrUndefined(minNumericDate) || (valueNumericDate >= minNumericDate)) && (isNullOrUndefined(maxNumericDate) || (valueNumericDate <= maxNumericDate)))) {
-                return null;
-            }
-            return formValidatorError(control, errorMessage ?? localizationData(tstdlFormLocalizationKeys.validation.date, { minimum: min ?? undefined, maximum: max ?? undefined }));
-        });
-    }
-    return dateValidator;
-}

package/form/validators/form.validator.d.ts

@@ -1,10 +0,0 @@
-import type { Signal } from '../../signals/api.js';
-import type { DynamicText } from '../../text/dynamic-text.model.js';
-import type { AbstractControl } from '../abstract-control.js';
-export type FormValidator<T> = (control: AbstractControl<T>) => Signal<FormValidatorError | null>;
-export type FormValidatorProvider<T> = () => FormValidator<T>;
-export type FormValidatorError = {
-    readonly control: AbstractControl;
-    readonly errorMessage: DynamicText;
-};
-export declare function formValidatorError(control: AbstractControl, errorMessage: DynamicText): FormValidatorError;

package/form/validators/form.validator.js

@@ -1,3 +0,0 @@
-export function formValidatorError(control, errorMessage) {
-    return { control, errorMessage };
-}