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

package/esm2022/lib/datatable/data-column/data-column.component.mjs

@@ -0,0 +1,114 @@
+/*!
+ * @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.
+ */
+/* eslint-disable @angular-eslint/component-selector, @angular-eslint/no-input-rename */
+import { Component, ContentChild, Input, TemplateRef } from '@angular/core';
+import * as i0 from "@angular/core";
+export class DataColumnComponent {
+    constructor() {
+        /** Id of the Column */
+        this.id = '';
+        /**
+         * Value type for the column. Possible settings are defined via DataColumnType.
+         * Example types: `text`, `date`, `image`, `icon`, `boolean`.
+         */
+        this.type = 'text';
+        /** Toggles ability to sort by this column, for example by clicking the column header. */
+        this.sortable = true;
+        /** Enable drag and drop for header column */
+        this.draggable = false;
+        /** Enable resize for column */
+        this.resizable = true;
+        /** Hide column */
+        this.isHidden = false;
+        /**
+         * Display title of the column, typically used for column headers. You can use the
+         * i18n resource key to get it translated automatically.
+         */
+        this.title = '';
+        this.subtitle = '';
+        /**  Toggles the editing support of the column data. */
+        this.editable = false;
+        /**  Enable or disable cell focus */
+        this.focus = true;
+    }
+    ngOnInit() {
+        if (!this.srTitle && this.key === '$thumbnail') {
+            this.srTitle = 'Thumbnail';
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: DataColumnComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.13", type: DataColumnComponent, isStandalone: true, selector: "data-column", inputs: { id: "id", key: "key", customData: "customData", type: "type", format: "format", sortable: "sortable", draggable: "draggable", resizable: "resizable", isHidden: "isHidden", title: "title", subtitle: "subtitle", formatTooltip: "formatTooltip", srTitle: ["sr-title", "srTitle"], cssClass: ["class", "cssClass"], copyContent: "copyContent", editable: "editable", focus: "focus", sortingKey: "sortingKey", order: "order", currencyConfig: "currencyConfig", decimalConfig: "decimalConfig", dateConfig: "dateConfig" }, queries: [{ propertyName: "template", first: true, predicate: TemplateRef, descendants: true }], ngImport: i0, template: '', isInline: true }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: DataColumnComponent, decorators: [{
+            type: Component,
+            args: [{
+                    selector: 'data-column',
+                    standalone: true,
+                    template: ''
+                }]
+        }], propDecorators: { id: [{
+                type: Input
+            }], key: [{
+                type: Input,
+                args: [{ required: true }]
+            }], customData: [{
+                type: Input
+            }], type: [{
+                type: Input
+            }], format: [{
+                type: Input
+            }], sortable: [{
+                type: Input
+            }], draggable: [{
+                type: Input
+            }], resizable: [{
+                type: Input
+            }], isHidden: [{
+                type: Input
+            }], title: [{
+                type: Input
+            }], subtitle: [{
+                type: Input
+            }], template: [{
+                type: ContentChild,
+                args: [TemplateRef]
+            }], formatTooltip: [{
+                type: Input
+            }], srTitle: [{
+                type: Input,
+                args: ['sr-title']
+            }], cssClass: [{
+                type: Input,
+                args: ['class']
+            }], copyContent: [{
+                type: Input
+            }], editable: [{
+                type: Input
+            }], focus: [{
+                type: Input
+            }], sortingKey: [{
+                type: Input
+            }], order: [{
+                type: Input
+            }], currencyConfig: [{
+                type: Input
+            }], decimalConfig: [{
+                type: Input
+            }], dateConfig: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/datatable/data-column/index.mjs

@@ -0,0 +1,18 @@
+/*!
+ * @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 './public-api';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9saWIvY29yZS9zcmMvbGliL2RhdGF0YWJsZS9kYXRhLWNvbHVtbi9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7Ozs7Ozs7Ozs7Ozs7O0dBZUc7QUFFSCxjQUFjLGNBQWMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qIVxuICogQGxpY2Vuc2VcbiAqIENvcHlyaWdodCDCqSAyMDA1LTIwMjUgSHlsYW5kIFNvZnR3YXJlLCBJbmMuIGFuZCBpdHMgYWZmaWxpYXRlcy4gQWxsIHJpZ2h0cyByZXNlcnZlZC5cbiAqXG4gKiBMaWNlbnNlZCB1bmRlciB0aGUgQXBhY2hlIExpY2Vuc2UsIFZlcnNpb24gMi4wICh0aGUgXCJMaWNlbnNlXCIpO1xuICogeW91IG1heSBub3QgdXNlIHRoaXMgZmlsZSBleGNlcHQgaW4gY29tcGxpYW5jZSB3aXRoIHRoZSBMaWNlbnNlLlxuICogWW91IG1heSBvYnRhaW4gYSBjb3B5IG9mIHRoZSBMaWNlbnNlIGF0XG4gKlxuICogICAgIGh0dHA6Ly93d3cuYXBhY2hlLm9yZy9saWNlbnNlcy9MSUNFTlNFLTIuMFxuICpcbiAqIFVubGVzcyByZXF1aXJlZCBieSBhcHBsaWNhYmxlIGxhdyBvciBhZ3JlZWQgdG8gaW4gd3JpdGluZywgc29mdHdhcmVcbiAqIGRpc3RyaWJ1dGVkIHVuZGVyIHRoZSBMaWNlbnNlIGlzIGRpc3RyaWJ1dGVkIG9uIGFuIFwiQVMgSVNcIiBCQVNJUyxcbiAqIFdJVEhPVVQgV0FSUkFOVElFUyBPUiBDT05ESVRJT05TIE9GIEFOWSBLSU5ELCBlaXRoZXIgZXhwcmVzcyBvciBpbXBsaWVkLlxuICogU2VlIHRoZSBMaWNlbnNlIGZvciB0aGUgc3BlY2lmaWMgbGFuZ3VhZ2UgZ292ZXJuaW5nIHBlcm1pc3Npb25zIGFuZFxuICogbGltaXRhdGlvbnMgdW5kZXIgdGhlIExpY2Vuc2UuXG4gKi9cblxuZXhwb3J0ICogZnJvbSAnLi9wdWJsaWMtYXBpJztcbiJdfQ==

package/esm2022/lib/datatable/data-column/public-api.mjs

@@ -0,0 +1,20 @@
+/*!
+ * @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 './data-column-list.component';
+export * from './data-column.component';
+export * from './data-column-header.component';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uL2xpYi9jb3JlL3NyYy9saWIvZGF0YXRhYmxlL2RhdGEtY29sdW1uL3B1YmxpYy1hcGkudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7Ozs7Ozs7Ozs7Ozs7OztHQWVHO0FBRUgsY0FBYyw4QkFBOEIsQ0FBQztBQUM3QyxjQUFjLHlCQUF5QixDQUFDO0FBQ3hDLGNBQWMsZ0NBQWdDLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKiFcbiAqIEBsaWNlbnNlXG4gKiBDb3B5cmlnaHQgwqkgMjAwNS0yMDI1IEh5bGFuZCBTb2Z0d2FyZSwgSW5jLiBhbmQgaXRzIGFmZmlsaWF0ZXMuIEFsbCByaWdodHMgcmVzZXJ2ZWQuXG4gKlxuICogTGljZW5zZWQgdW5kZXIgdGhlIEFwYWNoZSBMaWNlbnNlLCBWZXJzaW9uIDIuMCAodGhlIFwiTGljZW5zZVwiKTtcbiAqIHlvdSBtYXkgbm90IHVzZSB0aGlzIGZpbGUgZXhjZXB0IGluIGNvbXBsaWFuY2Ugd2l0aCB0aGUgTGljZW5zZS5cbiAqIFlvdSBtYXkgb2J0YWluIGEgY29weSBvZiB0aGUgTGljZW5zZSBhdFxuICpcbiAqICAgICBodHRwOi8vd3d3LmFwYWNoZS5vcmcvbGljZW5zZXMvTElDRU5TRS0yLjBcbiAqXG4gKiBVbmxlc3MgcmVxdWlyZWQgYnkgYXBwbGljYWJsZSBsYXcgb3IgYWdyZWVkIHRvIGluIHdyaXRpbmcsIHNvZnR3YXJlXG4gKiBkaXN0cmlidXRlZCB1bmRlciB0aGUgTGljZW5zZSBpcyBkaXN0cmlidXRlZCBvbiBhbiBcIkFTIElTXCIgQkFTSVMsXG4gKiBXSVRIT1VUIFdBUlJBTlRJRVMgT1IgQ09ORElUSU9OUyBPRiBBTlkgS0lORCwgZWl0aGVyIGV4cHJlc3Mgb3IgaW1wbGllZC5cbiAqIFNlZSB0aGUgTGljZW5zZSBmb3IgdGhlIHNwZWNpZmljIGxhbmd1YWdlIGdvdmVybmluZyBwZXJtaXNzaW9ucyBhbmRcbiAqIGxpbWl0YXRpb25zIHVuZGVyIHRoZSBMaWNlbnNlLlxuICovXG5cbmV4cG9ydCAqIGZyb20gJy4vZGF0YS1jb2x1bW4tbGlzdC5jb21wb25lbnQnO1xuZXhwb3J0ICogZnJvbSAnLi9kYXRhLWNvbHVtbi5jb21wb25lbnQnO1xuZXhwb3J0ICogZnJvbSAnLi9kYXRhLWNvbHVtbi1oZWFkZXIuY29tcG9uZW50JztcbiJdfQ==

package/esm2022/lib/datatable/datatable.module.mjs

@@ -0,0 +1,161 @@
+/*!
+ * @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 { DataTableCellComponent } from './components/datatable-cell/datatable-cell.component';
+import { DataTableRowComponent } from './components/datatable-row/datatable-row.component';
+import { DataTableComponent } from './components/datatable/datatable.component';
+import { DateCellComponent } from './components/date-cell/date-cell.component';
+import { ColumnsSelectorComponent } from './components/columns-selector/columns-selector.component';
+import { EmptyListBodyDirective, EmptyListComponent, EmptyListFooterDirective, EmptyListHeaderDirective } from './components/empty-list/empty-list.component';
+import { FileSizeCellComponent } from './components/filesize-cell/filesize-cell.component';
+import { LocationCellComponent } from './components/location-cell/location-cell.component';
+import { LoadingContentTemplateDirective } from './directives/loading-template.directive';
+import { NoContentTemplateDirective } from './directives/no-content-template.directive';
+import { NoPermissionTemplateDirective } from './directives/no-permission-template.directive';
+import { HeaderFilterTemplateDirective } from './directives/header-filter-template.directive';
+import { CustomEmptyContentTemplateDirective } from './directives/custom-empty-content-template.directive';
+import { CustomLoadingContentTemplateDirective } from './directives/custom-loading-template.directive';
+import { CustomNoPermissionTemplateDirective } from './directives/custom-no-permission-template.directive';
+import { MainMenuDataTableTemplateDirective } from './directives/main-data-table-action-template.directive';
+import { JsonCellComponent } from './components/json-cell/json-cell.component';
+import { DropZoneDirective } from './directives/drop-zone.directive';
+import { DataColumnComponent, DataColumnListComponent, DateColumnHeaderComponent } from './data-column';
+import { BooleanCellComponent } from './components/boolean-cell/boolean-cell.component';
+import { AmountCellComponent } from './components/amount-cell/amount-cell.component';
+import { NumberCellComponent } from './components/number-cell/number-cell.component';
+import { LocalizedDatePipe } from '../pipes';
+import { IconCellComponent } from './components/icon-cell/icon-cell.component';
+import { ResizableDirective } from './directives/resizable/resizable.directive';
+import { ResizeHandleDirective } from './directives/resizable/resize-handle.directive';
+import * as i0 from "@angular/core";
+export const DATATABLE_DIRECTIVES = [
+    BooleanCellComponent,
+    AmountCellComponent,
+    NumberCellComponent,
+    LocationCellComponent,
+    DateCellComponent,
+    IconCellComponent,
+    ColumnsSelectorComponent,
+    DataColumnComponent,
+    DataColumnListComponent,
+    DateColumnHeaderComponent,
+    LocalizedDatePipe,
+    ResizableDirective,
+    ResizeHandleDirective,
+    DropZoneDirective,
+    EmptyListComponent,
+    EmptyListHeaderDirective,
+    EmptyListBodyDirective,
+    EmptyListFooterDirective,
+    FileSizeCellComponent,
+    JsonCellComponent,
+    NoContentTemplateDirective,
+    NoPermissionTemplateDirective,
+    LoadingContentTemplateDirective,
+    HeaderFilterTemplateDirective,
+    CustomEmptyContentTemplateDirective,
+    CustomLoadingContentTemplateDirective,
+    CustomNoPermissionTemplateDirective,
+    MainMenuDataTableTemplateDirective,
+    DataTableRowComponent,
+    DataTableCellComponent,
+    DataTableComponent
+];
+/** @deprecated use `...DATATABLE_DIRECTIVES` instead, or import standalone components directly */
+export class DataTableModule {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: DataTableModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "18.2.13", ngImport: i0, type: DataTableModule, imports: [BooleanCellComponent,
+            AmountCellComponent,
+            NumberCellComponent,
+            LocationCellComponent,
+            DateCellComponent,
+            IconCellComponent,
+            ColumnsSelectorComponent,
+            DataColumnComponent,
+            DataColumnListComponent,
+            DateColumnHeaderComponent,
+            LocalizedDatePipe,
+            ResizableDirective,
+            ResizeHandleDirective,
+            DropZoneDirective,
+            EmptyListComponent,
+            EmptyListHeaderDirective,
+            EmptyListBodyDirective,
+            EmptyListFooterDirective,
+            FileSizeCellComponent,
+            JsonCellComponent,
+            NoContentTemplateDirective,
+            NoPermissionTemplateDirective,
+            LoadingContentTemplateDirective,
+            HeaderFilterTemplateDirective,
+            CustomEmptyContentTemplateDirective,
+            CustomLoadingContentTemplateDirective,
+            CustomNoPermissionTemplateDirective,
+            MainMenuDataTableTemplateDirective,
+            DataTableRowComponent,
+            DataTableCellComponent,
+            DataTableComponent], exports: [BooleanCellComponent,
+            AmountCellComponent,
+            NumberCellComponent,
+            LocationCellComponent,
+            DateCellComponent,
+            IconCellComponent,
+            ColumnsSelectorComponent,
+            DataColumnComponent,
+            DataColumnListComponent,
+            DateColumnHeaderComponent,
+            LocalizedDatePipe,
+            ResizableDirective,
+            ResizeHandleDirective,
+            DropZoneDirective,
+            EmptyListComponent,
+            EmptyListHeaderDirective,
+            EmptyListBodyDirective,
+            EmptyListFooterDirective,
+            FileSizeCellComponent,
+            JsonCellComponent,
+            NoContentTemplateDirective,
+            NoPermissionTemplateDirective,
+            LoadingContentTemplateDirective,
+            HeaderFilterTemplateDirective,
+            CustomEmptyContentTemplateDirective,
+            CustomLoadingContentTemplateDirective,
+            CustomNoPermissionTemplateDirective,
+            MainMenuDataTableTemplateDirective,
+            DataTableRowComponent,
+            DataTableCellComponent,
+            DataTableComponent] }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: DataTableModule, imports: [BooleanCellComponent,
+            AmountCellComponent,
+            NumberCellComponent,
+            LocationCellComponent,
+            DateCellComponent,
+            IconCellComponent,
+            ColumnsSelectorComponent,
+            FileSizeCellComponent,
+            JsonCellComponent,
+            DataTableCellComponent,
+            DataTableComponent] }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: DataTableModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [...DATATABLE_DIRECTIVES],
+                    exports: [...DATATABLE_DIRECTIVES]
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"datatable.module.js","sourceRoot":"","sources":["../../../../../../lib/core/src/lib/datatable/datatable.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 { DataTableCellComponent } from './components/datatable-cell/datatable-cell.component';\nimport { DataTableRowComponent } from './components/datatable-row/datatable-row.component';\nimport { DataTableComponent } from './components/datatable/datatable.component';\nimport { DateCellComponent } from './components/date-cell/date-cell.component';\nimport { ColumnsSelectorComponent } from './components/columns-selector/columns-selector.component';\nimport {\n    EmptyListBodyDirective,\n    EmptyListComponent,\n    EmptyListFooterDirective,\n    EmptyListHeaderDirective\n} from './components/empty-list/empty-list.component';\nimport { FileSizeCellComponent } from './components/filesize-cell/filesize-cell.component';\nimport { LocationCellComponent } from './components/location-cell/location-cell.component';\nimport { LoadingContentTemplateDirective } from './directives/loading-template.directive';\nimport { NoContentTemplateDirective } from './directives/no-content-template.directive';\nimport { NoPermissionTemplateDirective } from './directives/no-permission-template.directive';\nimport { HeaderFilterTemplateDirective } from './directives/header-filter-template.directive';\nimport { CustomEmptyContentTemplateDirective } from './directives/custom-empty-content-template.directive';\nimport { CustomLoadingContentTemplateDirective } from './directives/custom-loading-template.directive';\nimport { CustomNoPermissionTemplateDirective } from './directives/custom-no-permission-template.directive';\nimport { MainMenuDataTableTemplateDirective } from './directives/main-data-table-action-template.directive';\nimport { JsonCellComponent } from './components/json-cell/json-cell.component';\nimport { DropZoneDirective } from './directives/drop-zone.directive';\nimport { DataColumnComponent, DataColumnListComponent, DateColumnHeaderComponent } from './data-column';\nimport { BooleanCellComponent } from './components/boolean-cell/boolean-cell.component';\nimport { AmountCellComponent } from './components/amount-cell/amount-cell.component';\nimport { NumberCellComponent } from './components/number-cell/number-cell.component';\nimport { LocalizedDatePipe } from '../pipes';\nimport { IconCellComponent } from './components/icon-cell/icon-cell.component';\nimport { ResizableDirective } from './directives/resizable/resizable.directive';\nimport { ResizeHandleDirective } from './directives/resizable/resize-handle.directive';\n\nexport const DATATABLE_DIRECTIVES = [\n    BooleanCellComponent,\n    AmountCellComponent,\n    NumberCellComponent,\n    LocationCellComponent,\n    DateCellComponent,\n    IconCellComponent,\n    ColumnsSelectorComponent,\n    DataColumnComponent,\n    DataColumnListComponent,\n    DateColumnHeaderComponent,\n    LocalizedDatePipe,\n    ResizableDirective,\n    ResizeHandleDirective,\n    DropZoneDirective,\n    EmptyListComponent,\n    EmptyListHeaderDirective,\n    EmptyListBodyDirective,\n    EmptyListFooterDirective,\n    FileSizeCellComponent,\n    JsonCellComponent,\n    NoContentTemplateDirective,\n    NoPermissionTemplateDirective,\n    LoadingContentTemplateDirective,\n    HeaderFilterTemplateDirective,\n    CustomEmptyContentTemplateDirective,\n    CustomLoadingContentTemplateDirective,\n    CustomNoPermissionTemplateDirective,\n    MainMenuDataTableTemplateDirective,\n    DataTableRowComponent,\n    DataTableCellComponent,\n    DataTableComponent\n] as const;\n\n/** @deprecated use `...DATATABLE_DIRECTIVES` instead, or import standalone components directly */\n@NgModule({\n    imports: [...DATATABLE_DIRECTIVES],\n    exports: [...DATATABLE_DIRECTIVES]\n})\nexport class DataTableModule {}\n"]}

package/esm2022/lib/datatable/directives/custom-empty-content-template.directive.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 { Directive } from '@angular/core';
+import * as i0 from "@angular/core";
+/**
+ * Directive selectors without adf- prefix will be deprecated on 3.0.0.
+ * The empty-folder-content selector will be deprecated as it has been replace by
+ * adf-custom-empty-content-template.
+ */
+export class CustomEmptyContentTemplateDirective {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: CustomEmptyContentTemplateDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.2.13", type: CustomEmptyContentTemplateDirective, isStandalone: true, selector: "adf-custom-empty-content-template, empty-folder-content", ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: CustomEmptyContentTemplateDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: 'adf-custom-empty-content-template, empty-folder-content',
+                    standalone: true
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/datatable/directives/custom-loading-template.directive.mjs

@@ -0,0 +1,30 @@
+/*!
+ * @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 { Directive } from '@angular/core';
+import * as i0 from "@angular/core";
+export class CustomLoadingContentTemplateDirective {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: CustomLoadingContentTemplateDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.2.13", type: CustomLoadingContentTemplateDirective, isStandalone: true, selector: "adf-custom-loading-content-template", ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: CustomLoadingContentTemplateDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: 'adf-custom-loading-content-template',
+                    standalone: true
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY3VzdG9tLWxvYWRpbmctdGVtcGxhdGUuZGlyZWN0aXZlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vbGliL2NvcmUvc3JjL2xpYi9kYXRhdGFibGUvZGlyZWN0aXZlcy9jdXN0b20tbG9hZGluZy10ZW1wbGF0ZS5kaXJlY3RpdmUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7Ozs7Ozs7Ozs7Ozs7OztHQWVHO0FBRUgsT0FBTyxFQUFFLFNBQVMsRUFBRSxNQUFNLGVBQWUsQ0FBQzs7QUFNMUMsTUFBTSxPQUFPLHFDQUFxQzsrR0FBckMscUNBQXFDO21HQUFyQyxxQ0FBcUM7OzRGQUFyQyxxQ0FBcUM7a0JBSmpELFNBQVM7bUJBQUM7b0JBQ1AsUUFBUSxFQUFFLHFDQUFxQztvQkFDL0MsVUFBVSxFQUFFLElBQUk7aUJBQ25CIiwic291cmNlc0NvbnRlbnQiOlsiLyohXG4gKiBAbGljZW5zZVxuICogQ29weXJpZ2h0IMKpIDIwMDUtMjAyNSBIeWxhbmQgU29mdHdhcmUsIEluYy4gYW5kIGl0cyBhZmZpbGlhdGVzLiBBbGwgcmlnaHRzIHJlc2VydmVkLlxuICpcbiAqIExpY2Vuc2VkIHVuZGVyIHRoZSBBcGFjaGUgTGljZW5zZSwgVmVyc2lvbiAyLjAgKHRoZSBcIkxpY2Vuc2VcIik7XG4gKiB5b3UgbWF5IG5vdCB1c2UgdGhpcyBmaWxlIGV4Y2VwdCBpbiBjb21wbGlhbmNlIHdpdGggdGhlIExpY2Vuc2UuXG4gKiBZb3UgbWF5IG9idGFpbiBhIGNvcHkgb2YgdGhlIExpY2Vuc2UgYXRcbiAqXG4gKiAgICAgaHR0cDovL3d3dy5hcGFjaGUub3JnL2xpY2Vuc2VzL0xJQ0VOU0UtMi4wXG4gKlxuICogVW5sZXNzIHJlcXVpcmVkIGJ5IGFwcGxpY2FibGUgbGF3IG9yIGFncmVlZCB0byBpbiB3cml0aW5nLCBzb2Z0d2FyZVxuICogZGlzdHJpYnV0ZWQgdW5kZXIgdGhlIExpY2Vuc2UgaXMgZGlzdHJpYnV0ZWQgb24gYW4gXCJBUyBJU1wiIEJBU0lTLFxuICogV0lUSE9VVCBXQVJSQU5USUVTIE9SIENPTkRJVElPTlMgT0YgQU5ZIEtJTkQsIGVpdGhlciBleHByZXNzIG9yIGltcGxpZWQuXG4gKiBTZWUgdGhlIExpY2Vuc2UgZm9yIHRoZSBzcGVjaWZpYyBsYW5ndWFnZSBnb3Zlcm5pbmcgcGVybWlzc2lvbnMgYW5kXG4gKiBsaW1pdGF0aW9ucyB1bmRlciB0aGUgTGljZW5zZS5cbiAqL1xuXG5pbXBvcnQgeyBEaXJlY3RpdmUgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcblxuQERpcmVjdGl2ZSh7XG4gICAgc2VsZWN0b3I6ICdhZGYtY3VzdG9tLWxvYWRpbmctY29udGVudC10ZW1wbGF0ZScsXG4gICAgc3RhbmRhbG9uZTogdHJ1ZVxufSlcbmV4cG9ydCBjbGFzcyBDdXN0b21Mb2FkaW5nQ29udGVudFRlbXBsYXRlRGlyZWN0aXZlIHt9XG4iXX0=

package/esm2022/lib/datatable/directives/custom-no-permission-template.directive.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 { Directive } from '@angular/core';
+import * as i0 from "@angular/core";
+/**
+ * Directive selectors without adf- prefix will be deprecated on 3.0.0.
+ * The no-permission-content selector will be deprecated as it has been replace by
+ * adf-custom-no-permission-template.
+ */
+export class CustomNoPermissionTemplateDirective {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: CustomNoPermissionTemplateDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.2.13", type: CustomNoPermissionTemplateDirective, isStandalone: true, selector: "adf-custom-no-permission-template, no-permission-content", ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: CustomNoPermissionTemplateDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: 'adf-custom-no-permission-template, no-permission-content',
+                    standalone: true
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/datatable/directives/drop-zone.directive.mjs

@@ -0,0 +1,89 @@
+/*!
+ * @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 { Directive, Input, ElementRef, NgZone } from '@angular/core';
+import * as i0 from "@angular/core";
+export class DropZoneDirective {
+    constructor(elementRef, ngZone) {
+        this.ngZone = ngZone;
+        this.dropTarget = 'cell';
+        this.element = elementRef.nativeElement;
+    }
+    ngOnInit() {
+        this.ngZone.runOutsideAngular(() => {
+            this.element.addEventListener('dragenter', this.onDragEnter.bind(this));
+            this.element.addEventListener('dragover', this.onDragOver.bind(this));
+            this.element.addEventListener('drop', this.onDrop.bind(this));
+        });
+    }
+    ngOnDestroy() {
+        this.element.removeEventListener('dragenter', this.onDragEnter);
+        this.element.removeEventListener('dragover', this.onDragOver);
+        this.element.removeEventListener('drop', this.onDrop);
+    }
+    onDragEnter(event) {
+        const domEvent = this.dispatchDomEvent(event, 'dragenter');
+        if (domEvent.defaultPrevented) {
+            event.dataTransfer.dropEffect = 'copy';
+            event.preventDefault();
+            event.stopPropagation();
+        }
+    }
+    onDragOver(event) {
+        const domEvent = this.dispatchDomEvent(event, 'dragover');
+        if (domEvent.defaultPrevented) {
+            event.dataTransfer.dropEffect = 'copy';
+            event.preventDefault();
+            event.stopPropagation();
+        }
+    }
+    onDrop(event) {
+        const domEvent = this.dispatchDomEvent(event, 'drop');
+        if (domEvent.defaultPrevented) {
+            event.preventDefault();
+            event.stopPropagation();
+        }
+    }
+    dispatchDomEvent(originalEvent, eventName) {
+        const domEvent = new CustomEvent(`${this.dropTarget}-${eventName}`, {
+            detail: {
+                target: this.dropTarget,
+                event: originalEvent,
+                column: this.dropColumn,
+                row: this.dropRow
+            },
+            bubbles: true
+        });
+        this.element.dispatchEvent(domEvent);
+        return domEvent;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: DropZoneDirective, deps: [{ token: i0.ElementRef }, { token: i0.NgZone }], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.2.13", type: DropZoneDirective, isStandalone: true, selector: "[adf-drop-zone]", inputs: { dropTarget: "dropTarget", dropRow: "dropRow", dropColumn: "dropColumn" }, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: DropZoneDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[adf-drop-zone]',
+                    standalone: true
+                }]
+        }], ctorParameters: () => [{ type: i0.ElementRef }, { type: i0.NgZone }], propDecorators: { dropTarget: [{
+                type: Input
+            }], dropRow: [{
+                type: Input
+            }], dropColumn: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/datatable/directives/header-filter-template.directive.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 { ContentChild, Directive, TemplateRef } from '@angular/core';
+import { DataTableComponent } from '../components/datatable/datatable.component';
+import * as i0 from "@angular/core";
+import * as i1 from "../components/datatable/datatable.component";
+export class HeaderFilterTemplateDirective {
+    constructor(dataTable) {
+        this.dataTable = dataTable;
+    }
+    ngAfterContentInit() {
+        if (this.dataTable) {
+            this.dataTable.headerFilterTemplate = this.template;
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: HeaderFilterTemplateDirective, deps: [{ token: i1.DataTableComponent }], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "18.2.13", type: HeaderFilterTemplateDirective, isStandalone: true, selector: "adf-header-filter-template", queries: [{ propertyName: "template", first: true, predicate: TemplateRef, descendants: true }], ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: HeaderFilterTemplateDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: 'adf-header-filter-template',
+                    standalone: true
+                }]
+        }], ctorParameters: () => [{ type: i1.DataTableComponent }], propDecorators: { template: [{
+                type: ContentChild,
+                args: [TemplateRef]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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