@valtimo/dashboard 12.6.1 → 12.8.0

package/esm2022/lib/data-sources/task-count/components/task-count-configuration/task-count-configuration.component.mjs

@@ -0,0 +1,122 @@
+/*
+ * Copyright 2015-2024 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 { ChangeDetectionStrategy, Component, EventEmitter, Input, Output, } from '@angular/core';
+import { Operator, } from '../../../../models';
+import { BehaviorSubject, combineLatest, map, startWith, Subscription } from 'rxjs';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/forms";
+import * as i2 from "@ngx-translate/core";
+import * as i3 from "../../../../services";
+import * as i4 from "@angular/common";
+import * as i5 from "carbon-components-angular";
+import * as i6 from "@valtimo/components";
+import * as i7 from "../../../../pipes/widget-translate/widget-translate.pipe";
+export class TaskCountConfigurationComponent {
+    set disabled(disabledValue) {
+        if (disabledValue) {
+            this.form.disable();
+        }
+        else {
+            this.form.enable();
+        }
+    }
+    get queryConditions() {
+        return this.form.get('queryConditions');
+    }
+    set prefillConfiguration(configurationValue) {
+        if (configurationValue) {
+            this.defaultConditionValues$.next(configurationValue.queryConditions.map(condition => ({
+                key: condition.queryPath,
+                dropdown: condition.queryOperator,
+                value: condition.queryValue,
+            })));
+        }
+    }
+    constructor(fb, translateService, widgetTranslationService) {
+        this.fb = fb;
+        this.translateService = translateService;
+        this.widgetTranslationService = widgetTranslationService;
+        this.form = this.fb.group({
+            queryConditions: this.fb.control(null),
+        });
+        this._OPERATORS = [
+            Operator.NOT_EQUAL_TO,
+            Operator.EQUAL_TO,
+            Operator.GREATER_THAN,
+            Operator.GREATER_THAN_OR_EQUAL_TO,
+            Operator.LESS_THAN,
+            Operator.LESS_THAN_OR_EQUAL_TO,
+        ];
+        this.operatorItems$ = this.translateService
+            .stream('key')
+            .pipe(map(() => this._OPERATORS.map(operator => ({
+            id: operator,
+            content: this.widgetTranslationService.instant(operator, this.dataSourceKey),
+            selected: false,
+        }))));
+        this.defaultConditionValues$ = new BehaviorSubject(null);
+        this.allConditionsValid$ = new BehaviorSubject(true);
+        this.configurationEvent = new EventEmitter();
+        this._subscriptions = new Subscription();
+    }
+    ngOnInit() {
+        this.openFormSubscription();
+    }
+    ngOnDestroy() {
+        this._subscriptions.unsubscribe();
+    }
+    conditionsValueChange(values) {
+        if (values.length === 0) {
+            this.queryConditions.setValue(null);
+        }
+        else {
+            this.queryConditions.setValue(values.map(value => ({
+                queryPath: value.key,
+                queryOperator: value.dropdown,
+                queryValue: value.value,
+            })));
+        }
+    }
+    onAllConditionsValid(allConditionsValid) {
+        this.allConditionsValid$.next(allConditionsValid);
+    }
+    openFormSubscription() {
+        this._subscriptions.add(combineLatest([
+            this.form.valueChanges.pipe(startWith(this.form.value)),
+            this.allConditionsValid$,
+        ]).subscribe(([formValue, allConditionsValid]) => {
+            this.configurationEvent.emit({
+                valid: this.form.valid && allConditionsValid,
+                data: formValue,
+            });
+        }));
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: TaskCountConfigurationComponent, deps: [{ token: i1.FormBuilder }, { token: i2.TranslateService }, { token: i3.WidgetTranslationService }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.3.12", type: TaskCountConfigurationComponent, selector: "ng-component", inputs: { dataSourceKey: "dataSourceKey", disabled: "disabled", prefillConfiguration: "prefillConfiguration" }, outputs: { configurationEvent: "configurationEvent" }, ngImport: i0, template: "<!--\n  ~ Copyright 2015-2024 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\n<form\n  class=\"task-count-configuration-form\"\n  *ngIf=\"{operatorItems: operatorItems$} as obs\"\n  [formGroup]=\"form\"\n>\n  <div class=\"form__element conditions-multi-input\">\n    <cds-label\n      [helperText]=\"'conditionsHelperText' | widgetTranslate: dataSourceKey | async\"\n      class=\"conditions-label\"\n      >{{ 'conditions' | widgetTranslate: dataSourceKey | async }}</cds-label\n    >\n    <valtimo-carbon-multi-input\n      [addRowText]=\"'addCondition' | widgetTranslate: dataSourceKey | async\"\n      [defaultValues]=\"defaultConditionValues$ | async\"\n      [dropdownColumnTitle]=\"'operator' | widgetTranslate: dataSourceKey | async\"\n      [dropdownItems]=\"operatorItems$ | async\"\n      [fullWidth]=\"true\"\n      [initialAmountOfRows]=\"0\"\n      [keyColumnTitle]=\"'path' | widgetTranslate: dataSourceKey | async\"\n      [minimumAmountOfRows]=\"0\"\n      [valueColumnTitle]=\"'value' | widgetTranslate: dataSourceKey | async\"\n      type=\"keyDropdownValue\"\n      (allValuesValidEvent)=\"onAllConditionsValid($event)\"\n      (valueChange)=\"conditionsValueChange($event)\"\n    ></valtimo-carbon-multi-input>\n  </div>\n</form>\n", styles: ["::ng-deep .task-count-configuration-form .conditions-label{margin-bottom:16px}::ng-deep .task-count-configuration-form .conditions-multi-input .cds--form__helper-text{font-style:italic}\n/*!\n * Copyright 2015-2024 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"], dependencies: [{ kind: "directive", type: i4.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "directive", type: i1.ɵNgNoValidate, selector: "form:not([ngNoForm]):not([ngNativeValidate])" }, { kind: "directive", type: i1.NgControlStatusGroup, selector: "[formGroupName],[formArrayName],[ngModelGroup],[formGroup],form:not([ngNoForm]),[ngForm]" }, { kind: "directive", type: i1.FormGroupDirective, selector: "[formGroup]", inputs: ["formGroup"], outputs: ["ngSubmit"], exportAs: ["ngForm"] }, { kind: "component", type: i5.Label, selector: "cds-label, ibm-label", inputs: ["labelInputID", "disabled", "skeleton", "helperText", "invalidText", "invalid", "warn", "warnText", "ariaLabel"] }, { kind: "component", type: i6.CarbonMultiInputComponent, selector: "valtimo-carbon-multi-input", inputs: ["addRowText", "addRowTranslationKey", "arbitraryAmountTitles", "arbitraryValueAmount", "defaultValues", "deleteRowText", "deleteRowTranslationKey", "disabled", "dropdownColumnTitle", "dropdownItems", "dropdownWidth", "fullWidth", "hideAddButton", "hideDeleteButton", "initialAmountOfRows", "keyColumnTitle", "margin", "maxRows", "minimumAmountOfRows", "name", "required", "title", "titleTranslationKey", "tooltip", "type", "valueColumnTitle", "valuePathSelectorDocumentDefinitionName", "valuePathSelectorPrefixes", "valuePathSelectorShowDocumentDefinitionSelector", "valuePathSelectorNotation", "keyColumnFlex", "dropdownColumnFlex", "valueColumnFlex"], outputs: ["valueChange", "allValuesValidEvent"] }, { kind: "pipe", type: i4.AsyncPipe, name: "async" }, { kind: "pipe", type: i7.WidgetTranslatePipe, name: "widgetTranslate" }], changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: TaskCountConfigurationComponent, decorators: [{
+            type: Component,
+            args: [{ changeDetection: ChangeDetectionStrategy.OnPush, template: "<!--\n  ~ Copyright 2015-2024 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\n<form\n  class=\"task-count-configuration-form\"\n  *ngIf=\"{operatorItems: operatorItems$} as obs\"\n  [formGroup]=\"form\"\n>\n  <div class=\"form__element conditions-multi-input\">\n    <cds-label\n      [helperText]=\"'conditionsHelperText' | widgetTranslate: dataSourceKey | async\"\n      class=\"conditions-label\"\n      >{{ 'conditions' | widgetTranslate: dataSourceKey | async }}</cds-label\n    >\n    <valtimo-carbon-multi-input\n      [addRowText]=\"'addCondition' | widgetTranslate: dataSourceKey | async\"\n      [defaultValues]=\"defaultConditionValues$ | async\"\n      [dropdownColumnTitle]=\"'operator' | widgetTranslate: dataSourceKey | async\"\n      [dropdownItems]=\"operatorItems$ | async\"\n      [fullWidth]=\"true\"\n      [initialAmountOfRows]=\"0\"\n      [keyColumnTitle]=\"'path' | widgetTranslate: dataSourceKey | async\"\n      [minimumAmountOfRows]=\"0\"\n      [valueColumnTitle]=\"'value' | widgetTranslate: dataSourceKey | async\"\n      type=\"keyDropdownValue\"\n      (allValuesValidEvent)=\"onAllConditionsValid($event)\"\n      (valueChange)=\"conditionsValueChange($event)\"\n    ></valtimo-carbon-multi-input>\n  </div>\n</form>\n", styles: ["::ng-deep .task-count-configuration-form .conditions-label{margin-bottom:16px}::ng-deep .task-count-configuration-form .conditions-multi-input .cds--form__helper-text{font-style:italic}\n/*!\n * Copyright 2015-2024 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"] }]
+        }], ctorParameters: () => [{ type: i1.FormBuilder }, { type: i2.TranslateService }, { type: i3.WidgetTranslationService }], propDecorators: { dataSourceKey: [{
+                type: Input
+            }], disabled: [{
+                type: Input
+            }], prefillConfiguration: [{
+                type: Input
+            }], configurationEvent: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"task-count-configuration.component.js","sourceRoot":"","sources":["../../../../../../../../../projects/valtimo/dashboard/src/lib/data-sources/task-count/components/task-count-configuration/task-count-configuration.component.ts","../../../../../../../../../projects/valtimo/dashboard/src/lib/data-sources/task-count/components/task-count-configuration/task-count-configuration.component.html"],"names":[],"mappings":"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","sourcesContent":["/*\n * Copyright 2015-2024 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 {\n  ChangeDetectionStrategy,\n  Component,\n  EventEmitter,\n  Input,\n  OnDestroy,\n  OnInit,\n  Output,\n} from '@angular/core';\nimport {\n  ConfigurationOutput,\n  DataSourceConfigurationComponent,\n  Operator,\n  QueryCondition,\n} from '../../../../models';\nimport {BehaviorSubject, combineLatest, map, Observable, startWith, Subscription} from 'rxjs';\nimport {AbstractControl, FormBuilder} from '@angular/forms';\nimport {TaskCountConfiguration} from '../../models';\nimport {ListItemWithId, MultiInputKeyValue, MultiInputValues} from '@valtimo/components';\nimport {TranslateService} from '@ngx-translate/core';\nimport {WidgetTranslationService} from '../../../../services';\n\n@Component({\n  templateUrl: './task-count-configuration.component.html',\n  changeDetection: ChangeDetectionStrategy.OnPush,\n  styleUrls: ['./task-count-configuration.component.scss'],\n})\nexport class TaskCountConfigurationComponent\n  implements OnInit, OnDestroy, DataSourceConfigurationComponent\n{\n  @Input() public dataSourceKey: string;\n\n  public readonly form = this.fb.group({\n    queryConditions: this.fb.control(null),\n  });\n\n  @Input() public set disabled(disabledValue: boolean) {\n    if (disabledValue) {\n      this.form.disable();\n    } else {\n      this.form.enable();\n    }\n  }\n\n  private readonly _OPERATORS: Array<Operator> = [\n    Operator.NOT_EQUAL_TO,\n    Operator.EQUAL_TO,\n    Operator.GREATER_THAN,\n    Operator.GREATER_THAN_OR_EQUAL_TO,\n    Operator.LESS_THAN,\n    Operator.LESS_THAN_OR_EQUAL_TO,\n  ];\n\n  public readonly operatorItems$: Observable<Array<ListItemWithId>> = this.translateService\n    .stream('key')\n    .pipe(\n      map(() =>\n        this._OPERATORS.map(operator => ({\n          id: operator,\n          content: this.widgetTranslationService.instant(operator, this.dataSourceKey),\n          selected: false,\n        }))\n      )\n    );\n\n  public readonly defaultConditionValues$ = new BehaviorSubject<MultiInputValues | null>(null);\n  public readonly allConditionsValid$ = new BehaviorSubject<boolean>(true);\n\n  public get queryConditions(): AbstractControl<QueryCondition[]> {\n    return this.form.get('queryConditions');\n  }\n\n  @Input() set prefillConfiguration(configurationValue: TaskCountConfiguration) {\n    if (configurationValue) {\n      this.defaultConditionValues$.next(\n        configurationValue.queryConditions.map(condition => ({\n          key: condition.queryPath,\n          dropdown: condition.queryOperator,\n          value: condition.queryValue,\n        }))\n      );\n    }\n  }\n\n  @Output() public configurationEvent = new EventEmitter<\n    ConfigurationOutput<TaskCountConfiguration>\n  >();\n\n  private readonly _subscriptions = new Subscription();\n\n  constructor(\n    private readonly fb: FormBuilder,\n    private readonly translateService: TranslateService,\n    private readonly widgetTranslationService: WidgetTranslationService\n  ) {}\n\n  public ngOnInit(): void {\n    this.openFormSubscription();\n  }\n\n  public ngOnDestroy(): void {\n    this._subscriptions.unsubscribe();\n  }\n\n  public conditionsValueChange(values: Array<MultiInputKeyValue>): void {\n    if (values.length === 0) {\n      this.queryConditions.setValue(null);\n    } else {\n      this.queryConditions.setValue(\n        values.map(value => ({\n          queryPath: value.key,\n          queryOperator: value.dropdown,\n          queryValue: value.value,\n        }))\n      );\n    }\n  }\n\n  public onAllConditionsValid(allConditionsValid: boolean): void {\n    this.allConditionsValid$.next(allConditionsValid);\n  }\n\n  private openFormSubscription(): void {\n    this._subscriptions.add(\n      combineLatest([\n        this.form.valueChanges.pipe(startWith(this.form.value)),\n        this.allConditionsValid$,\n      ]).subscribe(([formValue, allConditionsValid]) => {\n        this.configurationEvent.emit({\n          valid: this.form.valid && allConditionsValid,\n          data: formValue as TaskCountConfiguration,\n        });\n      })\n    );\n  }\n}\n","<!--\n  ~ Copyright 2015-2024 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\n<form\n  class=\"task-count-configuration-form\"\n  *ngIf=\"{operatorItems: operatorItems$} as obs\"\n  [formGroup]=\"form\"\n>\n  <div class=\"form__element conditions-multi-input\">\n    <cds-label\n      [helperText]=\"'conditionsHelperText' | widgetTranslate: dataSourceKey | async\"\n      class=\"conditions-label\"\n      >{{ 'conditions' | widgetTranslate: dataSourceKey | async }}</cds-label\n    >\n    <valtimo-carbon-multi-input\n      [addRowText]=\"'addCondition' | widgetTranslate: dataSourceKey | async\"\n      [defaultValues]=\"defaultConditionValues$ | async\"\n      [dropdownColumnTitle]=\"'operator' | widgetTranslate: dataSourceKey | async\"\n      [dropdownItems]=\"operatorItems$ | async\"\n      [fullWidth]=\"true\"\n      [initialAmountOfRows]=\"0\"\n      [keyColumnTitle]=\"'path' | widgetTranslate: dataSourceKey | async\"\n      [minimumAmountOfRows]=\"0\"\n      [valueColumnTitle]=\"'value' | widgetTranslate: dataSourceKey | async\"\n      type=\"keyDropdownValue\"\n      (allValuesValidEvent)=\"onAllConditionsValid($event)\"\n      (valueChange)=\"conditionsValueChange($event)\"\n    ></valtimo-carbon-multi-input>\n  </div>\n</form>\n"]}

package/esm2022/lib/data-sources/task-count/index.mjs

@@ -0,0 +1,20 @@
+/*
+ * Copyright 2015-2024 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.
+ */
+export * from './components';
+export * from './models';
+export * from './task-count.module';
+export * from './task-count.specification';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy92YWx0aW1vL2Rhc2hib2FyZC9zcmMvbGliL2RhdGEtc291cmNlcy90YXNrLWNvdW50L2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7Ozs7Ozs7Ozs7OztHQWNHO0FBRUgsY0FBYyxjQUFjLENBQUM7QUFDN0IsY0FBYyxVQUFVLENBQUM7QUFDekIsY0FBYyxxQkFBcUIsQ0FBQztBQUNwQyxjQUFjLDRCQUE0QixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLypcbiAqIENvcHlyaWdodCAyMDE1LTIwMjQgUml0ZW5zZSBCViwgdGhlIE5ldGhlcmxhbmRzLlxuICpcbiAqIExpY2Vuc2VkIHVuZGVyIEVVUEwsIFZlcnNpb24gMS4yICh0aGUgXCJMaWNlbnNlXCIpO1xuICogeW91IG1heSBub3QgdXNlIHRoaXMgZmlsZSBleGNlcHQgaW4gY29tcGxpYW5jZSB3aXRoIHRoZSBMaWNlbnNlLlxuICogWW91IG1heSBvYnRhaW4gYSBjb3B5IG9mIHRoZSBMaWNlbnNlIGF0XG4gKlxuICogaHR0cHM6Ly9qb2ludXAuZWMuZXVyb3BhLmV1L2NvbGxlY3Rpb24vZXVwbC9ldXBsLXRleHQtZXVwbC0xMlxuICpcbiAqIFVubGVzcyByZXF1aXJlZCBieSBhcHBsaWNhYmxlIGxhdyBvciBhZ3JlZWQgdG8gaW4gd3JpdGluZywgc29mdHdhcmVcbiAqIGRpc3RyaWJ1dGVkIHVuZGVyIHRoZSBMaWNlbnNlIGlzIGRpc3RyaWJ1dGVkIG9uIGFuIFwiQVMgSVNcIiBiYXNpcyxcbiAqIFdJVEhPVVQgV0FSUkFOVElFUyBPUiBDT05ESVRJT05TIE9GIEFOWSBLSU5ELCBlaXRoZXIgZXhwcmVzcyBvciBpbXBsaWVkLlxuICogU2VlIHRoZSBMaWNlbnNlIGZvciB0aGUgc3BlY2lmaWMgbGFuZ3VhZ2UgZ292ZXJuaW5nIHBlcm1pc3Npb25zIGFuZFxuICogbGltaXRhdGlvbnMgdW5kZXIgdGhlIExpY2Vuc2UuXG4gKi9cblxuZXhwb3J0ICogZnJvbSAnLi9jb21wb25lbnRzJztcbmV4cG9ydCAqIGZyb20gJy4vbW9kZWxzJztcbmV4cG9ydCAqIGZyb20gJy4vdGFzay1jb3VudC5tb2R1bGUnO1xuZXhwb3J0ICogZnJvbSAnLi90YXNrLWNvdW50LnNwZWNpZmljYXRpb24nO1xuIl19

package/esm2022/lib/data-sources/task-count/models/index.mjs

@@ -0,0 +1,17 @@
+/*
+ * Copyright 2015-2024 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.
+ */
+export * from './task-count.model';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy92YWx0aW1vL2Rhc2hib2FyZC9zcmMvbGliL2RhdGEtc291cmNlcy90YXNrLWNvdW50L21vZGVscy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7Ozs7Ozs7Ozs7Ozs7R0FjRztBQUVILGNBQWMsb0JBQW9CLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKlxuICogQ29weXJpZ2h0IDIwMTUtMjAyNCBSaXRlbnNlIEJWLCB0aGUgTmV0aGVybGFuZHMuXG4gKlxuICogTGljZW5zZWQgdW5kZXIgRVVQTCwgVmVyc2lvbiAxLjIgKHRoZSBcIkxpY2Vuc2VcIik7XG4gKiB5b3UgbWF5IG5vdCB1c2UgdGhpcyBmaWxlIGV4Y2VwdCBpbiBjb21wbGlhbmNlIHdpdGggdGhlIExpY2Vuc2UuXG4gKiBZb3UgbWF5IG9idGFpbiBhIGNvcHkgb2YgdGhlIExpY2Vuc2UgYXRcbiAqXG4gKiBodHRwczovL2pvaW51cC5lYy5ldXJvcGEuZXUvY29sbGVjdGlvbi9ldXBsL2V1cGwtdGV4dC1ldXBsLTEyXG4gKlxuICogVW5sZXNzIHJlcXVpcmVkIGJ5IGFwcGxpY2FibGUgbGF3IG9yIGFncmVlZCB0byBpbiB3cml0aW5nLCBzb2Z0d2FyZVxuICogZGlzdHJpYnV0ZWQgdW5kZXIgdGhlIExpY2Vuc2UgaXMgZGlzdHJpYnV0ZWQgb24gYW4gXCJBUyBJU1wiIGJhc2lzLFxuICogV0lUSE9VVCBXQVJSQU5USUVTIE9SIENPTkRJVElPTlMgT0YgQU5ZIEtJTkQsIGVpdGhlciBleHByZXNzIG9yIGltcGxpZWQuXG4gKiBTZWUgdGhlIExpY2Vuc2UgZm9yIHRoZSBzcGVjaWZpYyBsYW5ndWFnZSBnb3Zlcm5pbmcgcGVybWlzc2lvbnMgYW5kXG4gKiBsaW1pdGF0aW9ucyB1bmRlciB0aGUgTGljZW5zZS5cbiAqL1xuXG5leHBvcnQgKiBmcm9tICcuL3Rhc2stY291bnQubW9kZWwnO1xuIl19

package/esm2022/lib/data-sources/task-count/models/task-count.model.mjs

@@ -0,0 +1,17 @@
+/*
+ * Copyright 2015-2024 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.
+ */
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidGFzay1jb3VudC5tb2RlbC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL3ZhbHRpbW8vZGFzaGJvYXJkL3NyYy9saWIvZGF0YS1zb3VyY2VzL3Rhc2stY291bnQvbW9kZWxzL3Rhc2stY291bnQubW9kZWwudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7Ozs7Ozs7Ozs7Ozs7O0dBY0ciLCJzb3VyY2VzQ29udGVudCI6WyIvKlxuICogQ29weXJpZ2h0IDIwMTUtMjAyNCBSaXRlbnNlIEJWLCB0aGUgTmV0aGVybGFuZHMuXG4gKlxuICogTGljZW5zZWQgdW5kZXIgRVVQTCwgVmVyc2lvbiAxLjIgKHRoZSBcIkxpY2Vuc2VcIik7XG4gKiB5b3UgbWF5IG5vdCB1c2UgdGhpcyBmaWxlIGV4Y2VwdCBpbiBjb21wbGlhbmNlIHdpdGggdGhlIExpY2Vuc2UuXG4gKiBZb3UgbWF5IG9idGFpbiBhIGNvcHkgb2YgdGhlIExpY2Vuc2UgYXRcbiAqXG4gKiBodHRwczovL2pvaW51cC5lYy5ldXJvcGEuZXUvY29sbGVjdGlvbi9ldXBsL2V1cGwtdGV4dC1ldXBsLTEyXG4gKlxuICogVW5sZXNzIHJlcXVpcmVkIGJ5IGFwcGxpY2FibGUgbGF3IG9yIGFncmVlZCB0byBpbiB3cml0aW5nLCBzb2Z0d2FyZVxuICogZGlzdHJpYnV0ZWQgdW5kZXIgdGhlIExpY2Vuc2UgaXMgZGlzdHJpYnV0ZWQgb24gYW4gXCJBUyBJU1wiIGJhc2lzLFxuICogV0lUSE9VVCBXQVJSQU5USUVTIE9SIENPTkRJVElPTlMgT0YgQU5ZIEtJTkQsIGVpdGhlciBleHByZXNzIG9yIGltcGxpZWQuXG4gKiBTZWUgdGhlIExpY2Vuc2UgZm9yIHRoZSBzcGVjaWZpYyBsYW5ndWFnZSBnb3Zlcm5pbmcgcGVybWlzc2lvbnMgYW5kXG4gKiBsaW1pdGF0aW9ucyB1bmRlciB0aGUgTGljZW5zZS5cbiAqL1xuXG5pbXBvcnQge1F1ZXJ5Q29uZGl0aW9ufSBmcm9tICcuLi8uLi8uLi9tb2RlbHMnO1xuXG5pbnRlcmZhY2UgVGFza0NvdW50Q29uZmlndXJhdGlvbiB7XG4gIHF1ZXJ5Q29uZGl0aW9uczogUXVlcnlDb25kaXRpb25bXTtcbn1cblxuZXhwb3J0IHtUYXNrQ291bnRDb25maWd1cmF0aW9ufTtcbiJdfQ==

package/esm2022/lib/data-sources/task-count/task-count.module.mjs

@@ -0,0 +1,57 @@
+/*
+ * Copyright 2015-2024 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 { NgModule } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import { DATA_SOURCE_TOKEN } from '../../constants';
+import { taskCountSpecification } from './task-count.specification';
+import { TaskCountConfigurationComponent } from './components';
+import { ReactiveFormsModule } from '@angular/forms';
+import { WidgetTranslatePipeModule } from '../../pipes';
+import { DropdownModule, InputModule } from 'carbon-components-angular';
+import { CarbonMultiInputModule } from '@valtimo/components';
+import * as i0 from "@angular/core";
+export class TaskCountDataSourceModule {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: TaskCountDataSourceModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "17.3.12", ngImport: i0, type: TaskCountDataSourceModule, declarations: [TaskCountConfigurationComponent], imports: [CommonModule,
+            ReactiveFormsModule,
+            WidgetTranslatePipeModule,
+            InputModule,
+            DropdownModule,
+            CarbonMultiInputModule], exports: [TaskCountConfigurationComponent] }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: TaskCountDataSourceModule, providers: [{ provide: DATA_SOURCE_TOKEN, useValue: taskCountSpecification, multi: true }], imports: [CommonModule,
+            ReactiveFormsModule,
+            WidgetTranslatePipeModule,
+            InputModule,
+            DropdownModule,
+            CarbonMultiInputModule] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: TaskCountDataSourceModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    declarations: [TaskCountConfigurationComponent],
+                    imports: [
+                        CommonModule,
+                        ReactiveFormsModule,
+                        WidgetTranslatePipeModule,
+                        InputModule,
+                        DropdownModule,
+                        CarbonMultiInputModule,
+                    ],
+                    exports: [TaskCountConfigurationComponent],
+                    providers: [{ provide: DATA_SOURCE_TOKEN, useValue: taskCountSpecification, multi: true }],
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/data-sources/task-count/task-count.specification.mjs

@@ -0,0 +1,69 @@
+/*
+ * Copyright 2015-2024 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 { CONDITIONS_HELPER_TEXTS } from '../shared';
+import { TaskCountConfigurationComponent } from './components';
+export const taskCountSpecification = {
+    dataSourceKey: 'task-count',
+    configurationComponent: TaskCountConfigurationComponent,
+    translations: {
+        de: {
+            title: 'Aufgabenanzahl',
+            '!=': 'Nicht gleichzusetzen mit',
+            '==': 'Gleich',
+            '>': 'Größer als',
+            '>=': 'Größer als oder gleich wie',
+            '<': 'Weniger als',
+            '<=': 'Gleich oder kleiner als',
+            path: 'Pfad',
+            operator: 'Operator',
+            value: 'Wert',
+            conditions: 'Bedingungen',
+            conditionsHelperText: `Geben Sie optionale Bedingungen zum Abrufen der Anzahl der Aufgaben. ${CONDITIONS_HELPER_TEXTS.DE('task:assignee')}`,
+            addCondition: 'Bedingung hinzufügen',
+        },
+        en: {
+            title: 'Task count',
+            '!=': 'Not equal to',
+            '==': 'Equal to',
+            '>': 'Greater than',
+            '>=': 'Greater than or equal to',
+            '<': 'Less than',
+            '<=': 'Less than or equal to',
+            path: 'Path (required)',
+            operator: 'Operator',
+            value: 'Value',
+            conditions: 'Conditions',
+            conditionsHelperText: `Specify optional conditions for retrieving the number of tasks. ${CONDITIONS_HELPER_TEXTS.EN('task:assignee')}`,
+            addCondition: 'Add condition',
+        },
+        nl: {
+            title: 'Aantal taken',
+            '!=': 'Niet gelijk aan',
+            '==': 'Gelijk aan',
+            '>': 'Groter dan',
+            '>=': 'Groter dan of gelijk aan',
+            '<': 'Minder dan',
+            '<=': 'Minder dan of gelijk aan',
+            path: 'Pad',
+            operator: 'Operator',
+            value: 'Waarde',
+            conditions: 'Condities',
+            conditionsHelperText: `Geef optionele condities op voor het ophalen van het aantal taken. ${CONDITIONS_HELPER_TEXTS.NL('task:assignee')}}`,
+            addCondition: 'Conditie toevoegen',
+        },
+    },
+};
+//# sourceMappingURL=data:application/json;base64,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