@sebgroup/green-angular 5.1.2 → 5.2.0

package/esm2022/v-angular/datepicker/date-control-value-accessor/date-control-value-accessor.component.mjs

@@ -0,0 +1,408 @@
+import { ChangeDetectorRef, ContentChild, Directive, ElementRef, EventEmitter, HostBinding, Inject, Input, Optional, Output, Self, TemplateRef, ViewChild, } from '@angular/core';
+import { NgControl, Validators, } from '@angular/forms';
+import { TRANSLOCO_SCOPE, TranslocoService, } from '@jsverse/transloco';
+import { Observable, Subject } from 'rxjs';
+import { takeUntil } from 'rxjs/operators';
+import { getFormatDateMask, getLocaleDateMask, getLocaleDateString, setDateFormatCharacters, } from '../models/dates';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/forms";
+import * as i2 from "@jsverse/transloco";
+// eslint-disable-next-line @angular-eslint/directive-class-suffix
+export class DateControlValueAccessorComponent {
+    /** Text shown before input has a written value. Default current date format by locale of transloco */
+    set placeholder(value) {
+        this._placeholder = value
+            ? setDateFormatCharacters(value, this.dateCharacters)
+            : value;
+        this.defaultPlaceholder = value
+            ? setDateFormatCharacters(value, this.dateCharacters)
+            : value;
+    }
+    get placeholder() {
+        return this._placeholder;
+    }
+    /**
+     * Settings for input mask for dates based on locale
+     * @see {@link getLocaleDateMask} use this tool to generate settings for `dateInputMask`
+     */
+    set dateInputMask(dateMask) {
+        // Hide input field
+        this.showInputDateSrc.next(false);
+        this.cdr.detectChanges();
+        this._dateInputMask = dateMask;
+        // Show input field to reload input-mask settings upon update
+        setTimeout(() => {
+            this.showInputDateSrc.next(true);
+            this.cdr.detectChanges();
+        }, 200);
+    }
+    get dateInputMask() {
+        return this._dateInputMask;
+    }
+    /** Hides the input borders and displays current value as a text. */
+    set locked(value) {
+        this._locked = value;
+        this.cdr.detectChanges();
+    }
+    get locked() {
+        return this._locked;
+    }
+    /** Override the required flag of the component. */
+    set required(value) {
+        this._required = value;
+    }
+    /** Child input element is considered required and changes default label template accordingly. */
+    get required() {
+        // if required is set => return required
+        if (this._required !== undefined)
+            return this._required;
+        // if required can be determined from the control => return control.required
+        if (this.ngControl?.control?.validator) {
+            const validator = this.ngControl?.control?.validator({});
+            return validator && validator.required;
+        }
+        return;
+    }
+    /** Override the invalid state of the component. */
+    set invalid(value) {
+        this._invalid = value;
+    }
+    /** The component has the invalid state, usually decorating the elements red and shows the first error. */
+    get invalid() {
+        if (this._invalid === true || this._invalid === false)
+            return this._invalid;
+        return (!!this.ngControl?.control?.invalid && this.ngControl?.control?.touched);
+    }
+    /** Override the valid state of the component. */
+    set valid(value) {
+        this._valid = value;
+    }
+    /** The component has the valid state, usually decorating the elements green. */
+    get valid() {
+        if (this._valid === true || this._valid === false)
+            return this._valid;
+        return !!this.ngControl?.control?.valid && this.ngControl?.control?.touched;
+    }
+    /**
+     * Creates a new BaseControlValueAccessorComponent.
+     * @param ngControl optional FormControl provided when component is used in a form, through dependency injection.
+     */
+    constructor(ngControl, translocoScope, elementRef, cdr, _transloco) {
+        this.ngControl = ngControl;
+        this.translocoScope = translocoScope;
+        this.elementRef = elementRef;
+        this.cdr = cdr;
+        this._transloco = _transloco;
+        /* ATTRIBUTES */
+        /** Id of the host element and is accessible by the children, automatically generated if not provided. */
+        this.id = window.ngv?.nextId('datepicker');
+        /** Adds an icon before each error message. */
+        this.withErrorIcon = false;
+        /** If set to true, the browser will try to automatically set focus to the child input element. */
+        this.autofocus = false;
+        this._locked = undefined;
+        /* STATES */
+        this._required = undefined;
+        this._invalid = undefined;
+        this._valid = undefined;
+        /** The component has the focused state, updated by the child input element's focus state. */
+        this.focused = false;
+        /** The component has the disabled state, usually muting the colors and removes interaction. */
+        this.disabled = false;
+        /** Toggler for showing or hiding the input field */
+        this.showInputDateSrc = new Subject();
+        /* TRIGGERS */
+        /** Emits focus events triggered by the child elements. */
+        this.ngvFocus = new EventEmitter();
+        /** Emits focus events triggered by the child elements. */
+        this.ngvBlur = new EventEmitter();
+        /* VALUE HANDLERS */
+        /** @internal */
+        this.onChange = (_) => { }; // eslint-disable-line @typescript-eslint/no-empty-function
+        /** @internal */
+        this.onTouched = () => { }; // eslint-disable-line @typescript-eslint/no-empty-function
+        /** @internal */
+        this.onValidatorChange = () => null;
+        this._state = null;
+        /** @internal */
+        // warningIcon = faTriangleExclamation;
+        /* LIFE CYCLE VARIABLES */
+        this._onDestroy$ = new Subject();
+        if (this.ngControl) {
+            // Note: we provide the value accessor through here, instead of
+            // the `providers` to avoid running into a circular import.
+            this.ngControl.valueAccessor = this;
+        }
+        if (this.translocoScope)
+            this.scope = this.translocoScope.toString();
+    }
+    static parseDateLike(value) {
+        try {
+            // if value is type of string,
+            if (value && typeof value === 'string')
+                value = new Date(value);
+            switch (true) {
+                // remove instances where the value will not correctly be parsed to a date string
+                case value == null:
+                case value?.toString() === 'Invalid Date':
+                    return null;
+                // if value-as-date is a valid date object, parse the value to YYYY-MM-DD format
+                case typeof value?.getMonth === 'function':
+                    return new Intl.DateTimeFormat('sv-SE').format(value);
+                default:
+                    return value;
+            }
+        }
+        catch (_e) {
+            return;
+        }
+    }
+    // eslint-disable-next-line @angular-eslint/contextual-lifecycle
+    ngOnInit() {
+        if (this.ngControl && this.ngControl.control) {
+            this.ngControl.control.setValidators(Validators.compose([this.ngControl.control.validator, this.validate]));
+        }
+        this._transloco.langChanges$.pipe(takeUntil(this._onDestroy$)).subscribe({
+            next: () => {
+                if (!this.locale && !this.dateFormat) {
+                    return this.updatePlaceholderAndMask();
+                }
+            },
+        });
+        // if reset observable has been passed, subscribe after updates
+        this.reset?.pipe(takeUntil(this._onDestroy$)).subscribe({
+            next: () => {
+                // reset value of controller
+                this.updateValue('');
+            },
+        });
+    }
+    // eslint-disable-next-line @angular-eslint/contextual-lifecycle
+    ngAfterViewInit() {
+        // if default value is set, then don't alter it. Otherwise, use
+        // current value of controller after initiation as default value
+        this.defaultValue = this.defaultValue ?? this.ngControl?.value;
+    }
+    ngOnChanges(changes) {
+        if (changes.defaultValue?.currentValue) {
+            this.updateValue(changes.defaultValue.currentValue);
+        }
+        if (changes.locale?.currentValue &&
+            !this.dateFormat &&
+            !changes.dateFormat?.currentValue) {
+            this.updatePlaceholderAndMask();
+        }
+        if (changes.dateFormat?.currentValue) {
+            this.updateFormat();
+        }
+        if (changes.dateCharacters?.currentValue) {
+            if (this.dateFormat) {
+                this.updateFormat();
+            }
+            else {
+                this.updatePlaceholderAndMask();
+            }
+        }
+        if (!!changes.dateLocale?.currentValue && !this.dateFormat) {
+            this.updatePlaceholderAndMask();
+        }
+    }
+    ngOnDestroy() {
+        this._onDestroy$.next(true);
+        this._onDestroy$.complete();
+    }
+    /** @internal */
+    onFocus(event) {
+        event.stopPropagation
+            ? event.stopPropagation()
+            : (event.cancelBubble = true);
+        this.focused = true;
+        this.ngvFocus.emit(event);
+    }
+    /** @internal */
+    onBlur(event) {
+        event.stopPropagation
+            ? event.stopPropagation()
+            : (event.cancelBubble = true);
+        this.onTouched();
+        this.focused = false;
+        this.ngvBlur.emit(event);
+    }
+    detectChanges() {
+        this.cdr.detectChanges();
+    }
+    /** Sets the focus on the actual input element. */
+    setFocus() {
+        if (this.inputRef)
+            this.inputRef.nativeElement.focus();
+    }
+    /**
+     * @internal
+     * Update placeholder  and input mask to match locale.
+     * Order if choice for locale:
+     * 1. dateLocale - Used for specifying which locale to be used for formatting date
+     * 2. locale - Unless dateLocale is not provided, use locale form current translation
+     * 3. transloco.getActiveLang - as last resort, get active language form trnasloco
+     * If locale is undefined, transloco.activeLang will be used instead.
+     */
+    updatePlaceholderAndMask() {
+        const locale = this.dateLocale ?? this.locale ?? this._transloco.getActiveLang();
+        this._placeholder = this.defaultPlaceholder
+            ? setDateFormatCharacters(this.defaultPlaceholder, this.dateCharacters)
+            : setDateFormatCharacters(getLocaleDateString(locale).toLowerCase(), this.dateCharacters);
+        this.dateInputMask = getLocaleDateMask(this.dateCharacters, locale);
+    }
+    updateFormat() {
+        if (this.dateFormat) {
+            this._placeholder = this.defaultPlaceholder
+                ? setDateFormatCharacters(this.defaultPlaceholder, this.dateCharacters)
+                : setDateFormatCharacters(this.dateFormat.toLowerCase(), this.dateCharacters);
+            this.dateInputMask = getFormatDateMask(this.dateFormat, this.dateCharacters);
+        }
+    }
+    // ----------------------------------------------------------------------------
+    // CONTROL VALUE ACCESSOR
+    // ----------------------------------------------------------------------------
+    /** Internal state/value that the native input element has. */
+    get state() {
+        return this._state;
+    }
+    /**
+     * Internal state/value that the native input element has.
+     */
+    set state(value) {
+        this._state = value;
+    }
+    /** Writes a new value to the child input element. */
+    writeValue(value) {
+        this.state = value;
+        this.onChange(this.state);
+    }
+    /** Registers a callback function that is called when the child input element's value changes. */
+    registerOnChange(fn) {
+        this.onChange = (value) => {
+            // ensure emitted value is a string | null | undefined
+            const emitValue = DateControlValueAccessorComponent.parseDateLike(value);
+            fn(emitValue);
+        };
+    }
+    /** Registers a callback function that is called when the child input element triggers on blur. */
+    registerOnTouched(fn) {
+        this.onTouched = fn;
+    }
+    /** Function that is called by the forms API when the control status changes to or from 'DISABLED'. */
+    setDisabledState(isDisabled) {
+        this.disabled = isDisabled;
+        // if displayDisabledAsLocked is enabled - update locked state based on disabled state
+        if (this.displayDisabledAsLocked) {
+            this.locked = isDisabled;
+        }
+    }
+    // ----------------------------------------------------------------------------
+    // VALIDATORS
+    // ----------------------------------------------------------------------------
+    /** Method that performs synchronous validation against the provided control. Used for internal validation. */
+    validate(_control) {
+        return null;
+    }
+    /** Registers a callback function to call when the validator inputs change. */
+    registerOnValidatorChange(fn) {
+        this.onValidatorChange = fn;
+    }
+    // ----------------------------------------------------------------------------
+    // HELPERS
+    // ----------------------------------------------------------------------------
+    /** Returns the first entry in an error object. */
+    get firstError() {
+        const errors = this.ngControl.errors;
+        if (!errors)
+            return null;
+        const code = Object.keys(errors)[0];
+        return { code, params: errors[code] };
+    }
+    updateValue(value = this.defaultValue) {
+        this.state = value;
+        this.onChange(this.state);
+        this.cdr.detectChanges();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: DateControlValueAccessorComponent, deps: [{ token: i1.NgControl, optional: true, self: true }, { token: TRANSLOCO_SCOPE, optional: true }, { token: i0.ElementRef }, { token: i0.ChangeDetectorRef }, { token: i2.TranslocoService }], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "17.3.12", type: DateControlValueAccessorComponent, inputs: { id: "id", name: "name", label: "label", placeholder: "placeholder", dateCharacters: "dateCharacters", role: "role", value: "value", error: "error", errorList: "errorList", withErrorIcon: "withErrorIcon", description: "description", autofocus: "autofocus", defaultValue: "defaultValue", reset: "reset", optional: "optional", dateInputMask: "dateInputMask", locked: "locked", displayDisabledAsLocked: "displayDisabledAsLocked", required: "required", invalid: "invalid", valid: "valid", focused: "focused", disabled: "disabled", locale: "locale", dateFormat: "dateFormat", dateLocale: "dateLocale" }, outputs: { ngvFocus: "ngvFocus", ngvBlur: "ngvBlur" }, host: { properties: { "attr.id": "this.id" } }, queries: [{ propertyName: "labelContentTpl", first: true, predicate: ["labelTpl"], descendants: true, read: TemplateRef }], viewQueries: [{ propertyName: "inputRef", first: true, predicate: ["input"], descendants: true, read: ElementRef }], usesOnChanges: true, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: DateControlValueAccessorComponent, decorators: [{
+            type: Directive
+        }], ctorParameters: () => [{ type: i1.NgControl, decorators: [{
+                    type: Self
+                }, {
+                    type: Optional
+                }] }, { type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [TRANSLOCO_SCOPE]
+                }] }, { type: i0.ElementRef }, { type: i0.ChangeDetectorRef }, { type: i2.TranslocoService }], propDecorators: { labelContentTpl: [{
+                type: ContentChild,
+                args: ['labelTpl', { read: TemplateRef }]
+            }], inputRef: [{
+                type: ViewChild,
+                args: ['input', { read: ElementRef }]
+            }], id: [{
+                type: HostBinding,
+                args: ['attr.id']
+            }, {
+                type: Input
+            }], name: [{
+                type: Input
+            }], label: [{
+                type: Input
+            }], placeholder: [{
+                type: Input
+            }], dateCharacters: [{
+                type: Input
+            }], role: [{
+                type: Input
+            }], value: [{
+                type: Input
+            }], error: [{
+                type: Input
+            }], errorList: [{
+                type: Input
+            }], withErrorIcon: [{
+                type: Input
+            }], description: [{
+                type: Input
+            }], autofocus: [{
+                type: Input
+            }], defaultValue: [{
+                type: Input
+            }], reset: [{
+                type: Input
+            }], optional: [{
+                type: Input
+            }], dateInputMask: [{
+                type: Input
+            }], locked: [{
+                type: Input
+            }], displayDisabledAsLocked: [{
+                type: Input
+            }], required: [{
+                type: Input
+            }], invalid: [{
+                type: Input
+            }], valid: [{
+                type: Input
+            }], focused: [{
+                type: Input
+            }], disabled: [{
+                type: Input
+            }], locale: [{
+                type: Input
+            }], dateFormat: [{
+                type: Input
+            }], dateLocale: [{
+                type: Input
+            }], ngvFocus: [{
+                type: Output
+            }], ngvBlur: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"date-control-value-accessor.component.js","sourceRoot":"","sources":["../../../../../../../libs/angular/src/v-angular/datepicker/date-control-value-accessor/date-control-value-accessor.component.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  AfterViewInit,\n  ChangeDetectorRef,\n  ContentChild,\n  Directive,\n  ElementRef,\n  EventEmitter,\n  HostBinding,\n  Inject,\n  Input,\n  OnChanges,\n  OnDestroy,\n  OnInit,\n  Optional,\n  Output,\n  Self,\n  SimpleChanges,\n  TemplateRef,\n  ViewChild,\n} from '@angular/core'\nimport {\n  AbstractControl,\n  ControlValueAccessor,\n  NgControl,\n  ValidationErrors,\n  Validator,\n  Validators,\n} from '@angular/forms'\nimport {\n  TRANSLOCO_SCOPE,\n  TranslocoScope,\n  TranslocoService,\n} from '@jsverse/transloco'\nimport { Observable, Subject } from 'rxjs'\nimport { takeUntil } from 'rxjs/operators'\n\nimport type { InputmaskOptions } from '@sebgroup/green-angular/src/v-angular/input-mask'\n\nimport {\n  DateCharacters,\n  getFormatDateMask,\n  getLocaleDateMask,\n  getLocaleDateString,\n  setDateFormatCharacters,\n} from '../models/dates'\n\n@Directive() // Required with Angular ivy compiler\n// eslint-disable-next-line @angular-eslint/directive-class-suffix\nexport abstract class DateControlValueAccessorComponent\n  implements\n    AfterViewInit,\n    OnInit,\n    OnChanges,\n    OnDestroy,\n    ControlValueAccessor,\n    Validator\n{\n  /** Custom template for displaying the content of the label.\n   * Specified by nesting an `<ng-template #labelTpl>Custom Label</ng-template>`.\n   */\n  @ContentChild('labelTpl', { read: TemplateRef })\n  labelContentTpl?: TemplateRef<undefined>\n\n  /** Reference to the native child input element. */\n  @ViewChild('input', { read: ElementRef }) inputRef?: ElementRef\n\n  /* ATTRIBUTES */\n\n  /** Id of the host element and is accessible by the children, automatically generated if not provided. */\n  @HostBinding('attr.id') @Input() id = (window as any).ngv?.nextId(\n    'datepicker',\n  )\n  /** Name of the child input element. */\n  @Input() name?: string\n  /** Label of the child input element using the default template.\n   * Can be overwritten by specifying an `<ng-template #labelTpl>Custom Label</ng-template>`.\n   */\n  @Input() label?: string\n  /** Text shown before input has a written value. Default current date format by locale of transloco */\n  @Input() set placeholder(value: string | undefined) {\n    this._placeholder = value\n      ? setDateFormatCharacters(value, this.dateCharacters)\n      : value\n    this.defaultPlaceholder = value\n      ? setDateFormatCharacters(value, this.dateCharacters)\n      : value\n  }\n  get placeholder() {\n    return this._placeholder\n  }\n  private _placeholder: string | undefined\n  defaultPlaceholder?: string\n  /** What characters to use in date placeholder, e.g. {year: 'Y', month: 'M', day: 'D'} */\n  @Input() dateCharacters?: DateCharacters\n  /** Role of the child input element. https://developer.mozilla.org/en-US/docs/Web/Accessibility/ARIA/Roles */\n  @Input() role?: string\n  /** Value of the child input element. Mostly used in conjunction with radio and checkboxes. */\n  @Input() value: any\n  /** An error string to be shown under invalid inputs. Overwrites any form errors. */\n  @Input() error?: string\n  /** A list of errors string to be shown under invalid inputs. Overwrites any form errors. */\n  @Input() errorList?: string[]\n  /** Adds an icon before each error message. */\n  @Input() withErrorIcon?: boolean = false\n  /** Description of the child input element. Both visibly and as `aria-label`. */\n  @Input() description?: string\n  /** If set to true, the browser will try to automatically set focus to the child input element. */\n  @Input() autofocus = false\n  /** Default value of the child input element. */\n  @Input() defaultValue?: any\n  /** If passed, the component will listen for updates and will reset its value. */\n  @Input() reset?: Observable<any>\n  /** Adds (Optional) to input label. */\n  @Input() optional?: boolean | null | undefined\n  /**\n   * Settings for input mask for dates based on locale\n   * @see {@link getLocaleDateMask} use this tool to generate settings for `dateInputMask`\n   */\n  @Input() set dateInputMask(dateMask: InputmaskOptions<Date>) {\n    // Hide input field\n    this.showInputDateSrc.next(false)\n    this.cdr.detectChanges()\n    this._dateInputMask = dateMask\n\n    // Show input field to reload input-mask settings upon update\n    setTimeout(() => {\n      this.showInputDateSrc.next(true)\n      this.cdr.detectChanges()\n    }, 200)\n  }\n  get dateInputMask(): InputmaskOptions<Date> {\n    return this._dateInputMask\n  }\n  private _dateInputMask!: InputmaskOptions<Date>\n\n  private _locked: boolean | null | undefined = undefined\n  /** Hides the input borders and displays current value as a text. */\n  @Input() set locked(value: boolean | null | undefined) {\n    this._locked = value\n    this.cdr.detectChanges()\n  }\n  get locked(): boolean | null | undefined {\n    return this._locked\n  }\n  /** If set to true, using a controls disabled state will display input as locked. */\n  @Input() displayDisabledAsLocked?: boolean | null | undefined\n\n  /* STATES */\n\n  private _required: boolean | null | undefined = undefined\n  /** Override the required flag of the component. */\n  @Input() set required(value: boolean | null | undefined) {\n    this._required = value\n  }\n  /** Child input element is considered required and changes default label template accordingly. */\n  get required(): boolean | null | undefined {\n    // if required is set => return required\n    if (this._required !== undefined) return this._required\n\n    // if required can be determined from the control => return control.required\n    if (this.ngControl?.control?.validator) {\n      const validator = this.ngControl?.control?.validator(\n        {} as AbstractControl,\n      )\n      return validator && validator.required\n    }\n\n    return\n  }\n\n  private _invalid: boolean | undefined = undefined\n  /** Override the invalid state of the component. */\n  @Input() set invalid(value: boolean) {\n    this._invalid = value\n  }\n  /** The component has the invalid state, usually decorating the elements red and shows the first error. */\n  get invalid(): boolean {\n    if (this._invalid === true || this._invalid === false) return this._invalid\n    return (\n      !!this.ngControl?.control?.invalid && this.ngControl?.control?.touched\n    )\n  }\n\n  private _valid: boolean | undefined = undefined\n  /** Override the valid state of the component. */\n  @Input() set valid(value: boolean) {\n    this._valid = value\n  }\n  /** The component has the valid state, usually decorating the elements green. */\n  get valid(): boolean {\n    if (this._valid === true || this._valid === false) return this._valid\n    return !!this.ngControl?.control?.valid && this.ngControl?.control?.touched\n  }\n\n  /** The component has the focused state, updated by the child input element's focus state. */\n  @Input() focused = false\n  /** The component has the disabled state, usually muting the colors and removes interaction. */\n  @Input() disabled = false\n  /** Locale for using correct language in the datepicker. */\n  @Input() locale: string | undefined\n  /** Date format used for placeholder and input mask. Should be in lower case {year: 'y', month: 'm', day: 'd'} */\n  @Input() dateFormat: string | undefined\n  /** Date locale used for placeholder and input mask. */\n  @Input() dateLocale: string | undefined\n\n  /** Toggler for showing or hiding the input field */\n  protected showInputDateSrc = new Subject<boolean>()\n\n  /* TRIGGERS */\n\n  /** Emits focus events triggered by the child elements. */\n  @Output() readonly ngvFocus = new EventEmitter()\n  /** Emits focus events triggered by the child elements. */\n  @Output() readonly ngvBlur = new EventEmitter()\n\n  /* VALUE HANDLERS */\n  /** @internal */\n  protected onChange = (_: any): void => {} // eslint-disable-line @typescript-eslint/no-empty-function\n  /** @internal */\n  protected onTouched = (): void => {} // eslint-disable-line @typescript-eslint/no-empty-function\n  /** @internal */\n  protected onValidatorChange: () => void = () => null\n  private _state: any = null\n\n  /* OTHER VARIABLES */\n  scope: string | undefined\n  /** @internal */\n  // warningIcon = faTriangleExclamation;\n\n  /* LIFE CYCLE VARIABLES */\n  private _onDestroy$ = new Subject<true>()\n\n  /**\n   * Creates a new BaseControlValueAccessorComponent.\n   * @param ngControl optional FormControl provided when component is used in a form, through dependency injection.\n   */\n  constructor(\n    @Self() @Optional() public ngControl: NgControl,\n    @Optional()\n    @Inject(TRANSLOCO_SCOPE)\n    protected translocoScope: TranslocoScope,\n    protected elementRef: ElementRef,\n    protected cdr: ChangeDetectorRef,\n    private _transloco: TranslocoService,\n  ) {\n    if (this.ngControl) {\n      // Note: we provide the value accessor through here, instead of\n      // the `providers` to avoid running into a circular import.\n      this.ngControl.valueAccessor = this\n    }\n\n    if (this.translocoScope) this.scope = this.translocoScope.toString()\n  }\n\n  static parseDateLike(value: any): null | undefined | string {\n    try {\n      // if value is type of string,\n      if (value && typeof value === 'string') value = new Date(value)\n      switch (true) {\n        // remove instances where the value will not correctly be parsed to a date string\n        case value == null:\n        case value?.toString() === 'Invalid Date':\n          return null\n        // if value-as-date is a valid date object, parse the value to YYYY-MM-DD format\n        case typeof value?.getMonth === 'function':\n          return new Intl.DateTimeFormat('sv-SE').format(value)\n        default:\n          return value as string\n      }\n    } catch (_e) {\n      return\n    }\n  }\n\n  // eslint-disable-next-line @angular-eslint/contextual-lifecycle\n  ngOnInit(): void {\n    if (this.ngControl && this.ngControl.control) {\n      this.ngControl.control.setValidators(\n        Validators.compose([this.ngControl.control.validator, this.validate]),\n      )\n    }\n\n    this._transloco.langChanges$.pipe(takeUntil(this._onDestroy$)).subscribe({\n      next: () => {\n        if (!this.locale && !this.dateFormat) {\n          return this.updatePlaceholderAndMask()\n        }\n      },\n    })\n\n    // if reset observable has been passed, subscribe after updates\n    this.reset?.pipe(takeUntil(this._onDestroy$)).subscribe({\n      next: () => {\n        // reset value of controller\n        this.updateValue('')\n      },\n    })\n  }\n\n  // eslint-disable-next-line @angular-eslint/contextual-lifecycle\n  ngAfterViewInit(): void {\n    // if default value is set, then don't alter it. Otherwise, use\n    // current value of controller after initiation as default value\n    this.defaultValue = this.defaultValue ?? this.ngControl?.value\n  }\n\n  ngOnChanges(changes: SimpleChanges): void {\n    if (changes.defaultValue?.currentValue) {\n      this.updateValue(changes.defaultValue.currentValue)\n    }\n\n    if (\n      changes.locale?.currentValue &&\n      !this.dateFormat &&\n      !changes.dateFormat?.currentValue\n    ) {\n      this.updatePlaceholderAndMask()\n    }\n\n    if (changes.dateFormat?.currentValue) {\n      this.updateFormat()\n    }\n\n    if (changes.dateCharacters?.currentValue) {\n      if (this.dateFormat) {\n        this.updateFormat()\n      } else {\n        this.updatePlaceholderAndMask()\n      }\n    }\n\n    if (!!changes.dateLocale?.currentValue && !this.dateFormat) {\n      this.updatePlaceholderAndMask()\n    }\n  }\n\n  ngOnDestroy(): void {\n    this._onDestroy$.next(true)\n    this._onDestroy$.complete()\n  }\n\n  /** @internal */\n  onFocus(event: Event) {\n    event.stopPropagation\n      ? event.stopPropagation()\n      : (event.cancelBubble = true)\n    this.focused = true\n    this.ngvFocus.emit(event)\n  }\n\n  /** @internal */\n  onBlur(event: Event) {\n    event.stopPropagation\n      ? event.stopPropagation()\n      : (event.cancelBubble = true)\n    this.onTouched()\n    this.focused = false\n    this.ngvBlur.emit(event)\n  }\n\n  detectChanges(): void {\n    this.cdr.detectChanges()\n  }\n\n  /** Sets the focus on the actual input element. */\n  setFocus() {\n    if (this.inputRef) this.inputRef.nativeElement.focus()\n  }\n\n  /**\n   * @internal\n   * Update placeholder  and input mask to match locale.\n   * Order if choice for locale:\n   * 1. dateLocale - Used for specifying which locale to be used for formatting date\n   * 2. locale - Unless dateLocale is not provided, use locale form current translation\n   * 3. transloco.getActiveLang - as last resort, get active language form trnasloco\n   * If locale is undefined, transloco.activeLang will be used instead.\n   */\n  updatePlaceholderAndMask() {\n    const locale =\n      this.dateLocale ?? this.locale ?? this._transloco.getActiveLang()\n\n    this._placeholder = this.defaultPlaceholder\n      ? setDateFormatCharacters(this.defaultPlaceholder, this.dateCharacters)\n      : setDateFormatCharacters(\n          getLocaleDateString(locale).toLowerCase(),\n          this.dateCharacters,\n        )\n    this.dateInputMask = getLocaleDateMask(this.dateCharacters, locale)\n  }\n\n  updateFormat() {\n    if (this.dateFormat) {\n      this._placeholder = this.defaultPlaceholder\n        ? setDateFormatCharacters(this.defaultPlaceholder, this.dateCharacters)\n        : setDateFormatCharacters(\n            this.dateFormat.toLowerCase(),\n            this.dateCharacters,\n          )\n      this.dateInputMask = getFormatDateMask(\n        this.dateFormat,\n        this.dateCharacters,\n      )\n    }\n  }\n\n  // ----------------------------------------------------------------------------\n  // CONTROL VALUE ACCESSOR\n  // ----------------------------------------------------------------------------\n\n  /** Internal state/value that the native input element has. */\n  get state() {\n    return this._state\n  }\n\n  /**\n   * Internal state/value that the native input element has.\n   */\n  set state(value) {\n    this._state = value\n  }\n\n  /** Writes a new value to the child input element. */\n  writeValue(value: any): void {\n    this.state = value\n    this.onChange(this.state)\n  }\n\n  /** Registers a callback function that is called when the child input element's value changes. */\n  registerOnChange(fn: (value: any) => void): void {\n    this.onChange = (value) => {\n      // ensure emitted value is a string | null | undefined\n      const emitValue = DateControlValueAccessorComponent.parseDateLike(value)\n      fn(emitValue)\n    }\n  }\n\n  /** Registers a callback function that is called when the child input element triggers on blur. */\n  registerOnTouched(fn: () => void): void {\n    this.onTouched = fn\n  }\n\n  /** Function that is called by the forms API when the control status changes to or from 'DISABLED'. */\n  setDisabledState(isDisabled: boolean): void {\n    this.disabled = isDisabled\n\n    // if displayDisabledAsLocked is enabled - update locked state based on disabled state\n    if (this.displayDisabledAsLocked) {\n      this.locked = isDisabled\n    }\n  }\n\n  // ----------------------------------------------------------------------------\n  // VALIDATORS\n  // ----------------------------------------------------------------------------\n\n  /** Method that performs synchronous validation against the provided control. Used for internal validation. */\n  validate(_control: AbstractControl): { [name: string]: any } | null {\n    return null\n  }\n\n  /** Registers a callback function to call when the validator inputs change. */\n  registerOnValidatorChange(fn: () => void): void {\n    this.onValidatorChange = fn\n  }\n\n  // ----------------------------------------------------------------------------\n  // HELPERS\n  // ----------------------------------------------------------------------------\n\n  /** Returns the first entry in an error object. */\n  get firstError(): { code: string; params: Record<string, any> } | null {\n    const errors: ValidationErrors | null = this.ngControl.errors\n    if (!errors) return null\n    const code = Object.keys(errors)[0]\n    return { code, params: errors[code] }\n  }\n\n  private updateValue(value = this.defaultValue) {\n    this.state = value\n    this.onChange(this.state)\n    this.cdr.detectChanges()\n  }\n}\n"]}

package/esm2022/v-angular/datepicker/datepicker.globals.mjs

@@ -0,0 +1,20 @@
+;
+(() => {
+    // Make sure there is an incremental ID each component can use
+    if (typeof window !== 'undefined' && !window.ngv) {
+        window.ngv = {
+            ids: { default: -1 },
+            nextId(namespace = 'default') {
+                let id = this.ids[namespace] || 0;
+                if (typeof this.ids[namespace] === 'number')
+                    id++;
+                this.ids[namespace] = id;
+                return namespace === 'default'
+                    ? `nggv-${id}`
+                    : `nggv-${namespace}-${id}`;
+            },
+        };
+    }
+})();
+export {};
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/v-angular/datepicker/datepicker.models.mjs

@@ -0,0 +1,56 @@
+import { formatDate } from '@angular/common';
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+export class CalendarMonth {
+    constructor(date) {
+        this._date = date ? new Date(date) : new Date();
+        this._date.setDate(1);
+        this._date.setHours(0, 0, 0, 0);
+        this.year = this._date.getFullYear();
+        this.month = this._date.getMonth();
+        this.id = formatDate(this._date, 'yyyyMM', 'en');
+    }
+    /** Creates an instance based of input year and month. */
+    static fromObject(obj) {
+        const objectDate = new Date(obj.year, obj.month, 1);
+        return new CalendarMonth(objectDate);
+    }
+    /** Returns a Date representation for the instance. */
+    get date() {
+        return new Date(this._date);
+    }
+    /** Returns the string id representing the instance in form of 'yyyyMM'. */
+    valueOf() {
+        return this.id;
+    }
+    /** Returns a new instance for next month. */
+    nextMonth() {
+        const next = this.date;
+        next.setMonth(this.month + 1);
+        return new CalendarMonth(next);
+    }
+    /** Returns a new instance for previous month. */
+    previousMonth() {
+        const previous = this.date;
+        previous.setMonth(this.month - 1);
+        return new CalendarMonth(previous);
+    }
+    /** Returns a new instance for next year. */
+    nextYear() {
+        const nextYear = this.date;
+        nextYear.setFullYear(nextYear.getFullYear() + 1);
+        return new CalendarMonth(nextYear);
+    }
+    /** Returns a new instance for previous year. */
+    previousYear() {
+        const previousYear = this.date;
+        previousYear.setFullYear(previousYear.getFullYear() - 1);
+        return new CalendarMonth(previousYear);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: CalendarMonth, deps: [{ token: Date }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: CalendarMonth }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: CalendarMonth, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [{ type: Date }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/v-angular/datepicker/datepicker.module.mjs

@@ -0,0 +1,63 @@
+import { CommonModule } from '@angular/common';
+import { CUSTOM_ELEMENTS_SCHEMA, NgModule } from '@angular/core';
+import { FormsModule, ReactiveFormsModule } from '@angular/forms';
+import { TranslocoModule } from '@jsverse/transloco';
+import { NggCoreWrapperModule } from '@sebgroup/green-angular/src/lib/shared';
+import { NggvInputMaskModule } from '@sebgroup/green-angular/src/v-angular/input-mask';
+import { CalendarControlComponent } from './components/calendar-control/calendar-control.component';
+import { CalendarComponent } from './components/calendar/calendar.component';
+import { DateInputComponent } from './components/date-input/date-input.component';
+import { DatepickerComponent } from './components/datepicker/datepicker.component';
+import { CalendarDateDirective } from './directives/calendar-date.directive';
+import { DateThookPipe } from './pipes/date-thook.pipe';
+import { IsDisabledPipe } from './pipes/is-disabled.pipe';
+import { MatchesPipe } from './pipes/matches.pipe';
+import * as i0 from "@angular/core";
+export class NggvDatepickerModule {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: NggvDatepickerModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "17.3.12", ngImport: i0, type: NggvDatepickerModule, declarations: [CalendarComponent,
+            CalendarDateDirective,
+            IsDisabledPipe,
+            DateThookPipe,
+            CalendarControlComponent,
+            DatepickerComponent,
+            DateInputComponent,
+            MatchesPipe], imports: [CommonModule,
+            FormsModule,
+            ReactiveFormsModule,
+            TranslocoModule,
+            NggvInputMaskModule,
+            NggCoreWrapperModule], exports: [DateInputComponent, DatepickerComponent] }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: NggvDatepickerModule, imports: [CommonModule,
+            FormsModule,
+            ReactiveFormsModule,
+            TranslocoModule,
+            NggvInputMaskModule,
+            NggCoreWrapperModule] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: NggvDatepickerModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    declarations: [
+                        CalendarComponent,
+                        CalendarDateDirective,
+                        IsDisabledPipe,
+                        DateThookPipe,
+                        CalendarControlComponent,
+                        DatepickerComponent,
+                        DateInputComponent,
+                        MatchesPipe,
+                    ],
+                    imports: [
+                        CommonModule,
+                        FormsModule,
+                        ReactiveFormsModule,
+                        TranslocoModule,
+                        NggvInputMaskModule,
+                        NggCoreWrapperModule,
+                    ],
+                    schemas: [CUSTOM_ELEMENTS_SCHEMA],
+                    exports: [DateInputComponent, DatepickerComponent],
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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