@alfresco/adf-core 8.1.0-16295248176 → 8.1.0-16320806191

package/esm2022/lib/card-view/models/card-view-selectitem.model.mjs

@@ -0,0 +1,41 @@
+/*!
+ * @license
+ * Copyright © 2005-2025 Hyland Software, Inc. and its affiliates. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * 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 { CardViewBaseItemModel } from './card-view-baseitem.model';
+import { of } from 'rxjs';
+import { switchMap } from 'rxjs/operators';
+export class CardViewSelectItemModel extends CardViewBaseItemModel {
+    constructor(cardViewSelectItemProperties) {
+        super(cardViewSelectItemProperties);
+        this.type = 'select';
+        this.autocompleteBased = false;
+        this.valueFetch$ = null;
+        this.displayNoneOption = cardViewSelectItemProperties.displayNoneOption !== undefined ? cardViewSelectItemProperties.displayNoneOption : true;
+        this.options$ = cardViewSelectItemProperties.options$;
+        this.autocompleteBased = cardViewSelectItemProperties.autocompleteBased || false;
+        this.valueFetch$ = this.options$.pipe(switchMap((options) => {
+            const option = options.find((o) => o.key === this.value?.toString());
+            return of(option ? option.label : '');
+        }));
+    }
+    get displayValue() {
+        return this.valueFetch$;
+    }
+    setValue(value) {
+        this.value = value;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/card-view/models/card-view-textitem.model.mjs

@@ -0,0 +1,40 @@
+/*!
+ * @license
+ * Copyright © 2005-2025 Hyland Software, Inc. and its affiliates. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * 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 { CardViewBaseItemModel } from './card-view-baseitem.model';
+export class CardViewTextItemModel extends CardViewBaseItemModel {
+    constructor(cardViewTextItemProperties) {
+        super(cardViewTextItemProperties);
+        this.type = 'text';
+        this.inputType = 'text';
+        this.multiline = !!cardViewTextItemProperties.multiline;
+        this.pipes = cardViewTextItemProperties.pipes || [];
+        this.clickCallBack = cardViewTextItemProperties.clickCallBack ? cardViewTextItemProperties.clickCallBack : null;
+        if (this.default && this.isEmpty()) {
+            this.value = this.default;
+        }
+    }
+    get displayValue() {
+        return this.applyPipes(this.value);
+    }
+    applyPipes(displayValue) {
+        if (this.pipes.length) {
+            displayValue = this.pipes.reduce((accumulator, { pipe, params = [] }) => pipe.transform(accumulator, ...params), displayValue);
+        }
+        return displayValue;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/card-view/models/card-view.models.mjs

@@ -0,0 +1,29 @@
+/*!
+ * @license
+ * Copyright © 2005-2025 Hyland Software, Inc. and its affiliates. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * 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 './card-view-baseitem.model';
+export * from './card-view-boolitem.model';
+export * from './card-view-dateitem.model';
+export * from './card-view-datetimeitem.model';
+export * from './card-view-floatitem.model';
+export * from './card-view-intitem.model';
+export * from './card-view-longitem.model';
+export * from './card-view-mapitem.model';
+export * from './card-view-textitem.model';
+export * from './card-view-keyvaluepairs.model';
+export * from './card-view-selectitem.model';
+export * from './card-view-arrayitem.model';
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/card-view/public-api.mjs

@@ -0,0 +1,25 @@
+/*!
+ * @license
+ * Copyright © 2005-2025 Hyland Software, Inc. and its affiliates. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * 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 { CardViewComponent, CardViewBoolItemComponent, CardViewDateItemComponent, CardViewMapItemComponent, CardViewTextItemComponent, CardViewSelectItemComponent, CardViewKeyValuePairsItemComponent, CardViewArrayItemComponent, SelectFilterInputComponent } from './components/card-view.components';
+export * from './interfaces/card-view.interfaces';
+export * from './interfaces/card-view.interfaces';
+export * from './validators/card-view.validators';
+export * from './models/card-view.models';
+export * from './services/card-view.services';
+export * from './card-view.module';
+export * from './components/card-view-item-dispatcher/card-view-item-dispatcher.component';
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/card-view/services/card-item-types.service.mjs

@@ -0,0 +1,54 @@
+/*!
+ * @license
+ * Copyright © 2005-2025 Hyland Software, Inc. and its affiliates. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * 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 { Injectable } from '@angular/core';
+import { CardViewDateItemComponent } from '../components/card-view-dateitem/card-view-dateitem.component';
+import { CardViewMapItemComponent } from '../components/card-view-mapitem/card-view-mapitem.component';
+import { CardViewTextItemComponent } from '../components/card-view-textitem/card-view-textitem.component';
+import { CardViewSelectItemComponent } from '../components/card-view-selectitem/card-view-selectitem.component';
+import { CardViewBoolItemComponent } from '../components/card-view-boolitem/card-view-boolitem.component';
+import { CardViewKeyValuePairsItemComponent } from '../components/card-view-keyvaluepairsitem/card-view-keyvaluepairsitem.component';
+import { DynamicComponentMapper, DynamicComponentResolver } from '../../common/services/dynamic-component-mapper.service';
+import { CardViewArrayItemComponent } from '../components/card-view-arrayitem/card-view-arrayitem.component';
+import * as i0 from "@angular/core";
+export class CardItemTypeService extends DynamicComponentMapper {
+    constructor() {
+        super(...arguments);
+        this.defaultValue = CardViewTextItemComponent;
+        this.types = {
+            text: DynamicComponentResolver.fromType(CardViewTextItemComponent),
+            select: DynamicComponentResolver.fromType(CardViewSelectItemComponent),
+            int: DynamicComponentResolver.fromType(CardViewTextItemComponent),
+            float: DynamicComponentResolver.fromType(CardViewTextItemComponent),
+            long: DynamicComponentResolver.fromType(CardViewTextItemComponent),
+            date: DynamicComponentResolver.fromType(CardViewDateItemComponent),
+            datetime: DynamicComponentResolver.fromType(CardViewDateItemComponent),
+            bool: DynamicComponentResolver.fromType(CardViewBoolItemComponent),
+            map: DynamicComponentResolver.fromType(CardViewMapItemComponent),
+            keyvaluepairs: DynamicComponentResolver.fromType(CardViewKeyValuePairsItemComponent),
+            array: DynamicComponentResolver.fromType(CardViewArrayItemComponent)
+        };
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: CardItemTypeService, deps: null, target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: CardItemTypeService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: CardItemTypeService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/card-view/services/card-view-update.service.mjs

@@ -0,0 +1,59 @@
+/*!
+ * @license
+ * Copyright © 2005-2025 Hyland Software, Inc. and its affiliates. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * 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 { Injectable } from '@angular/core';
+import { Subject } from 'rxjs';
+import * as i0 from "@angular/core";
+export const transformKeyToObject = (key, value) => {
+    const objectLevels = key.split('.').reverse();
+    return objectLevels.reduce((previousValue, currentValue) => ({ [currentValue]: previousValue }), value);
+};
+export class CardViewUpdateService {
+    constructor() {
+        this.itemUpdated$ = new Subject();
+        this.itemClicked$ = new Subject();
+        this.updateItem$ = new Subject();
+        this.autocompleteInputValue$ = new Subject();
+    }
+    update(property, newValue) {
+        this.itemUpdated$.next({
+            target: property,
+            changed: transformKeyToObject(property.key, newValue)
+        });
+    }
+    clicked(property) {
+        this.itemClicked$.next({
+            target: property
+        });
+    }
+    /**
+     * Updates the cardview items property
+     *
+     * @param notification notification value
+     */
+    updateElement(notification) {
+        this.updateItem$.next(notification);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: CardViewUpdateService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: CardViewUpdateService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: CardViewUpdateService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/card-view/services/card-view.services.mjs

@@ -0,0 +1,19 @@
+/*!
+ * @license
+ * Copyright © 2005-2025 Hyland Software, Inc. and its affiliates. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * 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 './card-item-types.service';
+export * from './card-view-update.service';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2FyZC12aWV3LnNlcnZpY2VzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vbGliL2NvcmUvc3JjL2xpYi9jYXJkLXZpZXcvc2VydmljZXMvY2FyZC12aWV3LnNlcnZpY2VzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7Ozs7Ozs7Ozs7Ozs7R0FlRztBQUVILGNBQWMsMkJBQTJCLENBQUM7QUFDMUMsY0FBYyw0QkFBNEIsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qIVxuICogQGxpY2Vuc2VcbiAqIENvcHlyaWdodCDCqSAyMDA1LTIwMjUgSHlsYW5kIFNvZnR3YXJlLCBJbmMuIGFuZCBpdHMgYWZmaWxpYXRlcy4gQWxsIHJpZ2h0cyByZXNlcnZlZC5cbiAqXG4gKiBMaWNlbnNlZCB1bmRlciB0aGUgQXBhY2hlIExpY2Vuc2UsIFZlcnNpb24gMi4wICh0aGUgXCJMaWNlbnNlXCIpO1xuICogeW91IG1heSBub3QgdXNlIHRoaXMgZmlsZSBleGNlcHQgaW4gY29tcGxpYW5jZSB3aXRoIHRoZSBMaWNlbnNlLlxuICogWW91IG1heSBvYnRhaW4gYSBjb3B5IG9mIHRoZSBMaWNlbnNlIGF0XG4gKlxuICogICAgIGh0dHA6Ly93d3cuYXBhY2hlLm9yZy9saWNlbnNlcy9MSUNFTlNFLTIuMFxuICpcbiAqIFVubGVzcyByZXF1aXJlZCBieSBhcHBsaWNhYmxlIGxhdyBvciBhZ3JlZWQgdG8gaW4gd3JpdGluZywgc29mdHdhcmVcbiAqIGRpc3RyaWJ1dGVkIHVuZGVyIHRoZSBMaWNlbnNlIGlzIGRpc3RyaWJ1dGVkIG9uIGFuIFwiQVMgSVNcIiBCQVNJUyxcbiAqIFdJVEhPVVQgV0FSUkFOVElFUyBPUiBDT05ESVRJT05TIE9GIEFOWSBLSU5ELCBlaXRoZXIgZXhwcmVzcyBvciBpbXBsaWVkLlxuICogU2VlIHRoZSBMaWNlbnNlIGZvciB0aGUgc3BlY2lmaWMgbGFuZ3VhZ2UgZ292ZXJuaW5nIHBlcm1pc3Npb25zIGFuZFxuICogbGltaXRhdGlvbnMgdW5kZXIgdGhlIExpY2Vuc2UuXG4gKi9cblxuZXhwb3J0ICogZnJvbSAnLi9jYXJkLWl0ZW0tdHlwZXMuc2VydmljZSc7XG5leHBvcnQgKiBmcm9tICcuL2NhcmQtdmlldy11cGRhdGUuc2VydmljZSc7XG4iXX0=

package/esm2022/lib/card-view/validators/card-view-item-float.validator.mjs

@@ -0,0 +1,31 @@
+/*!
+ * @license
+ * Copyright © 2005-2025 Hyland Software, Inc. and its affiliates. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * 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 class CardViewItemFloatValidator {
+    constructor() {
+        this.message = 'CORE.CARDVIEW.VALIDATORS.FLOAT_VALIDATION_ERROR';
+    }
+    isValid(value) {
+        if (Array.isArray(value)) {
+            return value.every(this.isDecimalNumber);
+        }
+        return value === '' || this.isDecimalNumber(value);
+    }
+    isDecimalNumber(value) {
+        return !isNaN(parseFloat(value)) && isFinite(value);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/card-view/validators/card-view-item-int.validator.mjs

@@ -0,0 +1,35 @@
+/*!
+ * @license
+ * Copyright © 2005-2025 Hyland Software, Inc. and its affiliates. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * 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 class CardViewItemIntValidator {
+    constructor() {
+        this.message = 'CORE.CARDVIEW.VALIDATORS.INT_VALIDATION_ERROR';
+    }
+    isValid(value) {
+        if (Array.isArray(value)) {
+            return value.every(this.isIntegerNumber);
+        }
+        return value === '' || (!isNaN(value) && this.isIntegerNumber(value) && this.isNotOnlySpace(value));
+    }
+    isIntegerNumber(value) {
+        const parsedNumber = Number(value);
+        return (parsedNumber | 0) === parsedNumber;
+    }
+    isNotOnlySpace(value) {
+        return String(value).trim() !== '';
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/card-view/validators/card-view-item-length.validator.mjs

@@ -0,0 +1,34 @@
+/*!
+ * @license
+ * Copyright © 2005-2025 Hyland Software, Inc. and its affiliates. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * 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 class CardViewItemLengthValidator {
+    constructor(minLength, maxLength) {
+        this.minLength = minLength;
+        this.maxLength = maxLength;
+        this.message = 'CORE.CARDVIEW.VALIDATORS.LENGTH_VALIDATION_ERROR';
+    }
+    isValid(value) {
+        if (Array.isArray(value)) {
+            return value.every((val) => this.isCorrectLength(val, this.minLength, this.maxLength));
+        }
+        return value === '' || this.isCorrectLength(value, this.minLength, this.maxLength);
+    }
+    isCorrectLength(value, min, max) {
+        const length = value.length;
+        return length >= min && length <= max;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/card-view/validators/card-view-item-long.validator.mjs

@@ -0,0 +1,35 @@
+/*!
+ * @license
+ * Copyright © 2005-2025 Hyland Software, Inc. and its affiliates. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * 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 class CardViewItemLongValidator {
+    constructor() {
+        this.message = 'CORE.CARDVIEW.VALIDATORS.LONG_VALIDATION_ERROR';
+    }
+    isValid(value) {
+        if (Array.isArray(value)) {
+            return value.every(this.isLongNumber);
+        }
+        return value === '' || (!isNaN(value) && this.isLongNumber(value) && this.isNotSpaceOnly(value));
+    }
+    isLongNumber(value) {
+        const longNumber = Number(value);
+        return Math.trunc(longNumber) === longNumber && longNumber >= Number.MIN_SAFE_INTEGER && longNumber <= Number.MAX_SAFE_INTEGER;
+    }
+    isNotSpaceOnly(value) {
+        return String(value).trim() !== '';
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/card-view/validators/card-view-item-match.validator.mjs

@@ -0,0 +1,35 @@
+/*!
+ * @license
+ * Copyright © 2005-2025 Hyland Software, Inc. and its affiliates. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * 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 class CardViewItemMatchValidator {
+    constructor(expression, flags, requiresMatch) {
+        this.expression = expression;
+        this.flags = flags;
+        this.requiresMatch = requiresMatch;
+        this.message = 'CORE.CARDVIEW.VALIDATORS.MATCH_VALIDATION_ERROR';
+    }
+    isValid(value) {
+        const regex = new RegExp(this.expression, this?.flags);
+        if (Array.isArray(value)) {
+            return value.every((val) => (this.requiresMatch ? this.matchRegex(val, regex) : !this.matchRegex(val, regex)));
+        }
+        return value === '' || (this.requiresMatch ? this.matchRegex(value, regex) : !this.matchRegex(value, regex));
+    }
+    matchRegex(value, regex) {
+        return regex.test(value);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/card-view/validators/card-view-item-minmax.validator.mjs

@@ -0,0 +1,35 @@
+/*!
+ * @license
+ * Copyright © 2005-2025 Hyland Software, Inc. and its affiliates. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * 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 { CardViewItemIntValidator } from './card-view-item-int.validator';
+export class CardViewItemMinMaxValidator {
+    constructor(minValue, maxValue) {
+        this.minValue = minValue;
+        this.maxValue = maxValue;
+        this.message = 'CORE.CARDVIEW.VALIDATORS.MINMAX_VALIDATION_ERROR';
+        this.intValidator = new CardViewItemIntValidator();
+    }
+    isValid(value) {
+        if (Array.isArray(value)) {
+            return value.every((val) => this.isInRange(val, this.minValue, this.maxValue));
+        }
+        return value === '' || (this.intValidator.isValid(value) && this.isInRange(value, this.minValue, this.maxValue));
+    }
+    isInRange(value, min, max) {
+        return value >= min && value <= max;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/card-view/validators/card-view-item-only-positive-int.validator.mjs

@@ -0,0 +1,32 @@
+/*!
+ * @license
+ * Copyright © 2005-2025 Hyland Software, Inc. and its affiliates. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * 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 class CardViewItemPositiveIntValidator {
+    constructor() {
+        this.message = 'CORE.CARDVIEW.VALIDATORS.ONLY_POSITIVE_NUMBER';
+    }
+    isValid(value) {
+        if (Array.isArray(value)) {
+            return value.every(this.isPositiveNumber);
+        }
+        const valueIsNotSet = value === '';
+        return valueIsNotSet || (!isNaN(value) && this.isPositiveNumber(value));
+    }
+    isPositiveNumber(value) {
+        return parseInt(value, 10) >= 0;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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