@alfresco/adf-content-services 8.1.0-16116688508 → 8.1.0-16117584844

package/esm2022/lib/material.module.mjs

@@ -0,0 +1,183 @@
+/*!
+ * @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 { NgModule } from '@angular/core';
+import { MatButtonModule } from '@angular/material/button';
+import { MatCardModule } from '@angular/material/card';
+import { MatCheckboxModule } from '@angular/material/checkbox';
+import { MatAutocompleteModule } from '@angular/material/autocomplete';
+import { MatChipsModule } from '@angular/material/chips';
+import { MatRippleModule, MatOptionModule } from '@angular/material/core';
+import { MatDatepickerModule } from '@angular/material/datepicker';
+import { MatDialogModule } from '@angular/material/dialog';
+import { MatExpansionModule } from '@angular/material/expansion';
+import { MatIconModule } from '@angular/material/icon';
+import { MatInputModule } from '@angular/material/input';
+import { MatListModule } from '@angular/material/list';
+import { MatMenuModule } from '@angular/material/menu';
+import { MatProgressBarModule } from '@angular/material/progress-bar';
+import { MatProgressSpinnerModule } from '@angular/material/progress-spinner';
+import { MatRadioModule } from '@angular/material/radio';
+import { MatSelectModule } from '@angular/material/select';
+import { MatSlideToggleModule } from '@angular/material/slide-toggle';
+import { MatSliderModule } from '@angular/material/slider';
+import { MatTreeModule } from '@angular/material/tree';
+import { MatBadgeModule } from '@angular/material/badge';
+import * as i0 from "@angular/core";
+/** @deprecated this module is deprecated and will be removed in future versions */
+export class MaterialModule {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: MaterialModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "18.2.13", ngImport: i0, type: MaterialModule, imports: [MatButtonModule,
+            MatAutocompleteModule,
+            MatChipsModule,
+            MatDialogModule,
+            MatIconModule,
+            MatCardModule,
+            MatInputModule,
+            MatListModule,
+            MatProgressSpinnerModule,
+            MatProgressBarModule,
+            MatRippleModule,
+            MatMenuModule,
+            MatOptionModule,
+            MatExpansionModule,
+            MatSelectModule,
+            MatCheckboxModule,
+            MatDatepickerModule,
+            MatSlideToggleModule,
+            MatRadioModule,
+            MatSliderModule,
+            MatTreeModule,
+            MatBadgeModule], exports: [MatButtonModule,
+            MatAutocompleteModule,
+            MatChipsModule,
+            MatDialogModule,
+            MatIconModule,
+            MatCardModule,
+            MatInputModule,
+            MatListModule,
+            MatProgressSpinnerModule,
+            MatProgressBarModule,
+            MatRippleModule,
+            MatMenuModule,
+            MatOptionModule,
+            MatExpansionModule,
+            MatSelectModule,
+            MatCheckboxModule,
+            MatDatepickerModule,
+            MatSlideToggleModule,
+            MatRadioModule,
+            MatSliderModule,
+            MatTreeModule,
+            MatBadgeModule] }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: MaterialModule, imports: [MatButtonModule,
+            MatAutocompleteModule,
+            MatChipsModule,
+            MatDialogModule,
+            MatIconModule,
+            MatCardModule,
+            MatInputModule,
+            MatListModule,
+            MatProgressSpinnerModule,
+            MatProgressBarModule,
+            MatRippleModule,
+            MatMenuModule,
+            MatOptionModule,
+            MatExpansionModule,
+            MatSelectModule,
+            MatCheckboxModule,
+            MatDatepickerModule,
+            MatSlideToggleModule,
+            MatRadioModule,
+            MatSliderModule,
+            MatTreeModule,
+            MatBadgeModule, MatButtonModule,
+            MatAutocompleteModule,
+            MatChipsModule,
+            MatDialogModule,
+            MatIconModule,
+            MatCardModule,
+            MatInputModule,
+            MatListModule,
+            MatProgressSpinnerModule,
+            MatProgressBarModule,
+            MatRippleModule,
+            MatMenuModule,
+            MatOptionModule,
+            MatExpansionModule,
+            MatSelectModule,
+            MatCheckboxModule,
+            MatDatepickerModule,
+            MatSlideToggleModule,
+            MatRadioModule,
+            MatSliderModule,
+            MatTreeModule,
+            MatBadgeModule] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: MaterialModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [
+                        MatButtonModule,
+                        MatAutocompleteModule,
+                        MatChipsModule,
+                        MatDialogModule,
+                        MatIconModule,
+                        MatCardModule,
+                        MatInputModule,
+                        MatListModule,
+                        MatProgressSpinnerModule,
+                        MatProgressBarModule,
+                        MatRippleModule,
+                        MatMenuModule,
+                        MatOptionModule,
+                        MatExpansionModule,
+                        MatSelectModule,
+                        MatCheckboxModule,
+                        MatDatepickerModule,
+                        MatSlideToggleModule,
+                        MatRadioModule,
+                        MatSliderModule,
+                        MatTreeModule,
+                        MatBadgeModule
+                    ],
+                    exports: [
+                        MatButtonModule,
+                        MatAutocompleteModule,
+                        MatChipsModule,
+                        MatDialogModule,
+                        MatIconModule,
+                        MatCardModule,
+                        MatInputModule,
+                        MatListModule,
+                        MatProgressSpinnerModule,
+                        MatProgressBarModule,
+                        MatRippleModule,
+                        MatMenuModule,
+                        MatOptionModule,
+                        MatExpansionModule,
+                        MatSelectModule,
+                        MatCheckboxModule,
+                        MatDatepickerModule,
+                        MatSlideToggleModule,
+                        MatRadioModule,
+                        MatSliderModule,
+                        MatTreeModule,
+                        MatBadgeModule
+                    ]
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"material.module.js","sourceRoot":"","sources":["../../../../../lib/content-services/src/lib/material.module.ts"],"names":[],"mappings":"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","sourcesContent":["/*!\n * @license\n * Copyright © 2005-2025 Hyland Software, Inc. and its affiliates. All rights reserved.\n *\n * Licensed under the Apache License, Version 2.0 (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 *     http://www.apache.org/licenses/LICENSE-2.0\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 { MatButtonModule } from '@angular/material/button';\nimport { MatCardModule } from '@angular/material/card';\nimport { MatCheckboxModule } from '@angular/material/checkbox';\nimport { MatAutocompleteModule } from '@angular/material/autocomplete';\nimport { MatChipsModule } from '@angular/material/chips';\nimport { MatRippleModule, MatOptionModule } from '@angular/material/core';\nimport { MatDatepickerModule } from '@angular/material/datepicker';\nimport { MatDialogModule } from '@angular/material/dialog';\nimport { MatExpansionModule } from '@angular/material/expansion';\nimport { MatIconModule } from '@angular/material/icon';\nimport { MatInputModule } from '@angular/material/input';\nimport { MatListModule } from '@angular/material/list';\nimport { MatMenuModule } from '@angular/material/menu';\nimport { MatProgressBarModule } from '@angular/material/progress-bar';\nimport { MatProgressSpinnerModule } from '@angular/material/progress-spinner';\nimport { MatRadioModule } from '@angular/material/radio';\nimport { MatSelectModule } from '@angular/material/select';\nimport { MatSlideToggleModule } from '@angular/material/slide-toggle';\nimport { MatSliderModule } from '@angular/material/slider';\nimport { MatTreeModule } from '@angular/material/tree';\nimport { MatBadgeModule } from '@angular/material/badge';\n\n/** @deprecated this module is deprecated and will be removed in future versions */\n@NgModule({\n    imports: [\n        MatButtonModule,\n        MatAutocompleteModule,\n        MatChipsModule,\n        MatDialogModule,\n        MatIconModule,\n        MatCardModule,\n        MatInputModule,\n        MatListModule,\n        MatProgressSpinnerModule,\n        MatProgressBarModule,\n        MatRippleModule,\n        MatMenuModule,\n        MatOptionModule,\n        MatExpansionModule,\n        MatSelectModule,\n        MatCheckboxModule,\n        MatDatepickerModule,\n        MatSlideToggleModule,\n        MatRadioModule,\n        MatSliderModule,\n        MatTreeModule,\n        MatBadgeModule\n    ],\n    exports: [\n        MatButtonModule,\n        MatAutocompleteModule,\n        MatChipsModule,\n        MatDialogModule,\n        MatIconModule,\n        MatCardModule,\n        MatInputModule,\n        MatListModule,\n        MatProgressSpinnerModule,\n        MatProgressBarModule,\n        MatRippleModule,\n        MatMenuModule,\n        MatOptionModule,\n        MatExpansionModule,\n        MatSelectModule,\n        MatCheckboxModule,\n        MatDatepickerModule,\n        MatSlideToggleModule,\n        MatRadioModule,\n        MatSliderModule,\n        MatTreeModule,\n        MatBadgeModule\n    ]\n})\nexport class MaterialModule {}\n"]}

package/esm2022/lib/mock/alfresco-api.service.mock.mjs

@@ -0,0 +1,43 @@
+/*!
+ * @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 { AlfrescoApiService } from '../services/alfresco-api.service';
+import { AppConfigService, StorageService } from '@alfresco/adf-core';
+import * as i0 from "@angular/core";
+import * as i1 from "@alfresco/adf-core";
+export class AlfrescoApiServiceMock extends AlfrescoApiService {
+    constructor(appConfig, storageService) {
+        super(appConfig, storageService);
+        this.appConfig = appConfig;
+        this.storageService = storageService;
+        if (!this.alfrescoApi) {
+            this.initAlfrescoApi();
+        }
+    }
+    initialize() {
+        return new Promise((resolve) => {
+            this.alfrescoApiInitialized.next(true);
+            resolve({});
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: AlfrescoApiServiceMock, deps: [{ token: i1.AppConfigService }, { token: i1.StorageService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: AlfrescoApiServiceMock }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: AlfrescoApiServiceMock, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [{ type: i1.AppConfigService }, { type: i1.StorageService }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/mock/date-range-search-filter.mock.mjs

@@ -0,0 +1,65 @@
+/*!
+ * @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 const mockSearchFilterWithoutDisplayedLabelsByField = {
+    id: 'test',
+    name: 'test',
+    expanded: false,
+    enabled: true,
+    component: {
+        selector: 'date-range',
+        settings: {
+            pattern: `test:'(.*?)'`,
+            field: 'test',
+            placeholder: 'test placeholder'
+        }
+    }
+};
+export const mockSearchFilterWithWrongDisplayedLabelsByField = {
+    id: 'test',
+    name: 'test',
+    expanded: false,
+    enabled: true,
+    component: {
+        selector: 'date-range',
+        settings: {
+            pattern: `test:'(.*?)'`,
+            field: 'test',
+            placeholder: 'test placeholder',
+            displayedLabelsByField: {
+                'wrong-test': 'test-tab-label'
+            }
+        }
+    }
+};
+export const mockSearchFilterWithDisplayedLabelsByField = {
+    id: 'test',
+    name: 'test',
+    expanded: false,
+    enabled: true,
+    component: {
+        selector: 'date-range',
+        settings: {
+            pattern: `test:'(.*?)'`,
+            field: 'test',
+            placeholder: 'test placeholder',
+            displayedLabelsByField: {
+                test: 'test-tab-label'
+            }
+        }
+    }
+};
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/mock/document-library.model.mock.mjs

@@ -0,0 +1,84 @@
+/*!
+ * @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 { ContentInfo, Node, NodeEntry, PathInfo } from '@alfresco/js-api';
+export class FileNode extends NodeEntry {
+    constructor(name, mimeType, id) {
+        super();
+        this.entry = new Node();
+        this.entry.id = id || 'file-id';
+        this.entry.isFile = true;
+        this.entry.isFolder = false;
+        this.entry.name = name;
+        this.entry.path = new PathInfo();
+        this.entry.content = new ContentInfo();
+        this.entry.content.mimeType = mimeType || 'text/plain';
+        this.entry.properties = {};
+    }
+}
+export class FolderNode extends NodeEntry {
+    constructor(name) {
+        super();
+        this.entry = new Node();
+        this.entry.id = 'folder-id';
+        this.entry.isFile = false;
+        this.entry.isFolder = true;
+        this.entry.name = name;
+        this.entry.path = new PathInfo();
+        this.entry.aspectNames = ['cm:folder'];
+        this.entry.properties = {};
+    }
+}
+export class SmartFolderNode extends NodeEntry {
+    constructor(name) {
+        super();
+        this.entry = new Node();
+        this.entry.id = 'smart-folder-id';
+        this.entry.isFile = false;
+        this.entry.isFolder = true;
+        this.entry.name = name;
+        this.entry.path = new PathInfo();
+        this.entry.aspectNames = ['smf:systemConfigSmartFolder'];
+        this.entry.properties = {};
+    }
+}
+export class RuleFolderNode extends NodeEntry {
+    constructor(name) {
+        super();
+        this.entry = new Node();
+        this.entry.id = 'rule-folder-id';
+        this.entry.isFile = false;
+        this.entry.isFolder = true;
+        this.entry.name = name;
+        this.entry.path = new PathInfo();
+        this.entry.aspectNames = ['rule:rules'];
+        this.entry.properties = {};
+    }
+}
+export class LinkFolderNode extends NodeEntry {
+    constructor(name) {
+        super();
+        this.entry = new Node();
+        this.entry.id = 'link-folder-id';
+        this.entry.isFile = false;
+        this.entry.isFolder = true;
+        this.entry.nodeType = 'app:folderlink';
+        this.entry.name = name;
+        this.entry.path = new PathInfo();
+        this.entry.properties = {};
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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