@valtimo/components 12.41.0 → 12.43.0

package/esm2022/lib/components/form-io/form-io.module.mjs

@@ -36,11 +36,19 @@ import { FormioDummyComponent } from './form-io-dummy/dummy.component';
 import { LayerModule } from 'carbon-components-angular';
 import { FormIoCurrencyComponent } from './form-io-currency/currency.component';
 import { applyDataGridPatch } from './patches/patched-datagrid';
+import { registerFormioFlatpickr, setFormioFlatpickrLocale } from './formio-flatpickr';
 import * as i0 from "@angular/core";
+import * as i1 from "@ngx-translate/core";
 // Apply FormIO patches before any form renders
 applyDataGridPatch();
 export class FormIoModule {
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: FormIoModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    constructor(translateService) {
+        this.translateService = translateService;
+        registerFormioFlatpickr();
+        setFormioFlatpickrLocale((this.translateService.currentLang));
+        this.translateService.onLangChange.subscribe(({ lang }) => setFormioFlatpickrLocale(lang));
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: FormIoModule, deps: [{ token: i1.TranslateService }], target: i0.ɵɵFactoryTarget.NgModule }); }
     static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "17.3.12", ngImport: i0, type: FormIoModule, declarations: [FormioComponent,
             FormioBuilderComponent,
             FormIoUploaderComponent,
@@ -126,5 +134,5 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImpo
                         },
                     ],
                 }]
-        }] });
-//# sourceMappingURL=data:application/json;base64,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
+        }], ctorParameters: () => [{ type: i1.TranslateService }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"form-io.module.js","sourceRoot":"","sources":["../../../../../../../projects/valtimo/components/src/lib/components/form-io/form-io.module.ts"],"names":[],"mappings":"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","sourcesContent":["/*\n * Copyright 2015-2026 Ritense BV, the Netherlands.\n *\n * Licensed under EUPL, Version 1.2 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * https://joinup.ec.europa.eu/collection/eupl/eupl-text-eupl-12\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" basis,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport {NgModule} from '@angular/core';\nimport {CommonModule} from '@angular/common';\nimport {FormioComponent} from './form-io.component';\nimport {FormioBuilderComponent} from './form-io-builder.component';\nimport {FormioAppConfig, FormioModule} from '@formio/angular';\nimport {getFormioAppConfig} from './formio-config';\nimport {FormIoUploaderComponent} from './form-io-uploader/form-io-uploader.component';\nimport {DropzoneModule} from '../dropzone/dropzone.module';\nimport {TranslateModule, TranslateService} from '@ngx-translate/core';\nimport {DocumentModule} from '@valtimo/document';\nimport {FormIoDomService} from './services/form-io-dom.service';\nimport {FileSizeModule} from '../file-size/file-size.module';\nimport {ResourceModule} from '@valtimo/resource';\nimport {RouterModule} from '@angular/router';\nimport {FormIoCurrentUserComponent} from './form-io-current-user/form-io-current-user.component';\nimport {ConfigService} from '@valtimo/config';\nimport {FormIoIbanComponent} from './form-io-iban/iban.component';\nimport {ReactiveFormsModule} from '@angular/forms';\nimport {FormioValueResolverSelectorComponent} from './formio-value-resolver-selector/formio-value-resolver-selector.component';\nimport {FormioDummyComponent} from './form-io-dummy/dummy.component';\nimport {LayerModule} from 'carbon-components-angular';\nimport {FormIoCurrencyComponent} from './form-io-currency/currency.component';\nimport {applyDataGridPatch} from './patches/patched-datagrid';\nimport {registerFormioFlatpickr, setFormioFlatpickrLocale} from './formio-flatpickr';\n\n// Apply FormIO patches before any form renders\napplyDataGridPatch();\n\n@NgModule({\n  imports: [\n    CommonModule,\n    FormioModule,\n    DropzoneModule,\n    TranslateModule,\n    DocumentModule,\n    FileSizeModule,\n    ResourceModule,\n    RouterModule,\n    ReactiveFormsModule,\n    FormioValueResolverSelectorComponent,\n    LayerModule,\n  ],\n  declarations: [\n    FormioComponent,\n    FormioBuilderComponent,\n    FormIoUploaderComponent,\n    FormIoCurrentUserComponent,\n    FormIoIbanComponent,\n    FormIoCurrencyComponent,\n    FormioDummyComponent,\n  ],\n  exports: [\n    FormioComponent,\n    FormioBuilderComponent,\n    FormIoUploaderComponent,\n    FormIoCurrentUserComponent,\n    FormIoIbanComponent,\n    FormIoCurrencyComponent,\n    FormioDummyComponent,\n  ],\n  providers: [\n    FormIoDomService,\n    {\n      provide: FormioAppConfig,\n      deps: [ConfigService],\n      useFactory: (configService: ConfigService) => getFormioAppConfig(configService.config),\n    },\n  ],\n})\nexport class FormIoModule {\n  constructor(private translateService: TranslateService) {\n    registerFormioFlatpickr();\n    setFormioFlatpickrLocale((this.translateService.currentLang))\n    this.translateService.onLangChange.subscribe(({lang}) => setFormioFlatpickrLocale(lang));\n  }\n}\n"]}

package/esm2022/lib/components/form-io/formio-flatpickr.mjs

@@ -0,0 +1,65 @@
+/*
+ * Copyright 2015-2026 Ritense BV, the Netherlands.
+ *
+ * Licensed under EUPL, Version 1.2 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * https://joinup.ec.europa.eu/collection/eupl/eupl-text-eupl-12
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import flatpickr from 'flatpickr';
+import { Dutch } from 'flatpickr/dist/l10n/nl';
+import { Formio } from 'formiojs';
+/**
+ * Formio only set the language on the first load.
+ * This script can change the language of all active datepickers.
+ * For all active datepickers, the new language is set and the component instance is reloaded.
+ * The new language is immediately visible without a window reload.
+ */
+const DEFAULT_LOCALE_KEY = 'en';
+const SUPPORTED_LOCALES = new Proxy({
+    en: flatpickr.l10ns.default,
+    nl: Dutch,
+}, {
+    get: (target, prop) => target[prop] ?? target[DEFAULT_LOCALE_KEY],
+});
+let activeLocale = DEFAULT_LOCALE_KEY;
+const activeInstances = new Set();
+function getLocaleConfig(locale) {
+    return SUPPORTED_LOCALES[locale];
+}
+export function setFormioFlatpickrLocale(langKey) {
+    activeLocale = langKey in SUPPORTED_LOCALES ? langKey : DEFAULT_LOCALE_KEY;
+    const localeConfig = getLocaleConfig(activeLocale);
+    activeInstances.forEach(instance => instance.set('locale', localeConfig));
+}
+export function registerFormioFlatpickr() {
+    Object.entries(SUPPORTED_LOCALES).forEach(([key, config]) => {
+        flatpickr.l10ns[key] = config;
+    });
+    const formioFlatpickr = function (element, config) {
+        const result = flatpickr(element, { ...config, locale: activeLocale });
+        const instances = Array.isArray(result) ? result : [result];
+        instances.forEach(instance => {
+            if (!instance) {
+                return;
+            }
+            activeInstances.add(instance);
+            instance.config.onDestroy.push(() => activeInstances.delete(instance));
+        });
+        return result;
+    };
+    Object.assign(formioFlatpickr, flatpickr);
+    window.flatpickr = formioFlatpickr;
+    Formio.libraries['flatpickr-nl'] = {
+        loaded: true,
+        ready: Promise.resolve(Dutch),
+    };
+}
+//# sourceMappingURL=data:application/json;base64,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

package/fesm2022/valtimo-components.mjs

@@ -50,13 +50,13 @@ import { trigger, transition, style, animate } from '@angular/animations';
 import * as i1$6 from '@angular/cdk/overlay';
 import { OverlayModule } from '@angular/cdk/overlay';
 import Currency from '@tadashi/currency';
+import flatpickr from 'flatpickr';
+import { Dutch } from 'flatpickr/dist/l10n/nl';
 import * as i2$4 from 'ngx-spinner';
 import { NgxSpinnerModule } from 'ngx-spinner';
 import * as i2$5 from 'ng-multiselect-dropdown';
 import { NgMultiSelectDropDownModule } from 'ng-multiselect-dropdown';
 import { v4 } from 'uuid';
-import flatpickr from 'flatpickr';
-import { Dutch } from 'flatpickr/dist/l10n/nl';
 import { German } from 'flatpickr/dist/l10n/de';
 import { english } from 'flatpickr/dist/l10n/default';
 
@@ -10124,6 +10124,68 @@ function applyDataGridPatch() {
     Components.setComponent('datagrid', PatchedDataGrid);
 }
 
+/*
+ * Copyright 2015-2026 Ritense BV, the Netherlands.
+ *
+ * Licensed under EUPL, Version 1.2 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * https://joinup.ec.europa.eu/collection/eupl/eupl-text-eupl-12
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+/**
+ * Formio only set the language on the first load.
+ * This script can change the language of all active datepickers.
+ * For all active datepickers, the new language is set and the component instance is reloaded.
+ * The new language is immediately visible without a window reload.
+ */
+const DEFAULT_LOCALE_KEY = 'en';
+const SUPPORTED_LOCALES = new Proxy({
+    en: flatpickr.l10ns.default,
+    nl: Dutch,
+}, {
+    get: (target, prop) => target[prop] ?? target[DEFAULT_LOCALE_KEY],
+});
+let activeLocale = DEFAULT_LOCALE_KEY;
+const activeInstances = new Set();
+function getLocaleConfig(locale) {
+    return SUPPORTED_LOCALES[locale];
+}
+function setFormioFlatpickrLocale(langKey) {
+    activeLocale = langKey in SUPPORTED_LOCALES ? langKey : DEFAULT_LOCALE_KEY;
+    const localeConfig = getLocaleConfig(activeLocale);
+    activeInstances.forEach(instance => instance.set('locale', localeConfig));
+}
+function registerFormioFlatpickr() {
+    Object.entries(SUPPORTED_LOCALES).forEach(([key, config]) => {
+        flatpickr.l10ns[key] = config;
+    });
+    const formioFlatpickr = function (element, config) {
+        const result = flatpickr(element, { ...config, locale: activeLocale });
+        const instances = Array.isArray(result) ? result : [result];
+        instances.forEach(instance => {
+            if (!instance) {
+                return;
+            }
+            activeInstances.add(instance);
+            instance.config.onDestroy.push(() => activeInstances.delete(instance));
+        });
+        return result;
+    };
+    Object.assign(formioFlatpickr, flatpickr);
+    window.flatpickr = formioFlatpickr;
+    Formio$1.libraries['flatpickr-nl'] = {
+        loaded: true,
+        ready: Promise.resolve(Dutch),
+    };
+}
+
 /*
  * Copyright 2015-2026 Ritense BV, the Netherlands.
  *
@@ -10142,7 +10204,13 @@ function applyDataGridPatch() {
 // Apply FormIO patches before any form renders
 applyDataGridPatch();
 class FormIoModule {
-    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: FormIoModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    constructor(translateService) {
+        this.translateService = translateService;
+        registerFormioFlatpickr();
+        setFormioFlatpickrLocale((this.translateService.currentLang));
+        this.translateService.onLangChange.subscribe(({ lang }) => setFormioFlatpickrLocale(lang));
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: FormIoModule, deps: [{ token: i1.TranslateService }], target: i0.ɵɵFactoryTarget.NgModule }); }
     static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "17.3.12", ngImport: i0, type: FormIoModule, declarations: [FormioComponent,
             FormioBuilderComponent,
             FormIoUploaderComponent,
@@ -10228,7 +10296,7 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImpo
                         },
                     ],
                 }]
-        }] });
+        }], ctorParameters: () => [{ type: i1.TranslateService }] });
 
 /*
  * Copyright 2015-2024 Ritense BV, the Netherlands.