angular-slickgrid 3.2.0 → 4.0.0

package/esm2020/app/modules/angular-slickgrid/global-grid-options.mjs

@@ -0,0 +1,243 @@
+import { DelimiterType, EventNamingStyle, FileType, Filters, OperatorType } from '@slickgrid-universal/common';
+/** Global Grid Options Defaults */
+export const GlobalGridOptions = {
+    alwaysShowVerticalScroll: true,
+    autoEdit: false,
+    asyncEditorLoading: false,
+    autoFitColumnsOnFirstLoad: true,
+    autoResize: {
+        applyResizeToContainer: true,
+        calculateAvailableSizeBy: 'window',
+        bottomPadding: 20,
+        minHeight: 180,
+        minWidth: 300,
+        rightPadding: 0
+    },
+    cellHighlightCssClass: 'slick-cell-modified',
+    checkboxSelector: {
+        cssClass: 'slick-cell-checkboxsel'
+    },
+    columnPicker: {
+        fadeSpeed: 0,
+        hideForceFitButton: false,
+        hideSyncResizeButton: true,
+        headerColumnValueExtractor: pickerHeaderColumnValueExtractor
+    },
+    cellMenu: {
+        autoAdjustDrop: true,
+        autoAlignSide: true,
+        hideCloseButton: true,
+        hideCommandSection: false,
+        hideOptionSection: false,
+    },
+    contextMenu: {
+        autoAdjustDrop: true,
+        autoAlignSide: true,
+        hideCloseButton: true,
+        hideClearAllGrouping: false,
+        hideCollapseAllGroups: false,
+        hideCommandSection: false,
+        hideCopyCellValueCommand: false,
+        hideExpandAllGroups: false,
+        hideExportCsvCommand: false,
+        hideExportExcelCommand: false,
+        hideExportTextDelimitedCommand: true,
+        hideMenuOnScroll: true,
+        hideOptionSection: false,
+        iconCopyCellValueCommand: 'fa fa-clone',
+        iconExportCsvCommand: 'fa fa-download',
+        iconExportExcelCommand: 'fa fa-file-excel-o text-success',
+        iconExportTextDelimitedCommand: 'fa fa-download',
+    },
+    customFooterOptions: {
+        dateFormat: 'YYYY-MM-DD, hh:mm a',
+        hideRowSelectionCount: false,
+        hideTotalItemCount: false,
+        hideLastUpdateTimestamp: true,
+        footerHeight: 25,
+        leftContainerClass: 'col-xs-12 col-sm-5',
+        rightContainerClass: 'col-xs-6 col-sm-7',
+        metricSeparator: '|',
+        metricTexts: {
+            items: 'items',
+            itemsKey: 'ITEMS',
+            itemsSelected: 'items selected',
+            itemsSelectedKey: 'ITEMS_SELECTED',
+            of: 'of',
+            ofKey: 'OF',
+        }
+    },
+    dataView: {
+        syncGridSelection: true,
+        syncGridSelectionWithBackendService: false, // but disable it when using backend services
+    },
+    datasetIdPropertyName: 'id',
+    defaultFilter: Filters.input,
+    defaultBackendServiceFilterTypingDebounce: 500,
+    defaultColumnSortFieldId: 'id',
+    defaultFilterPlaceholder: '🔎︎',
+    defaultFilterRangeOperator: OperatorType.rangeInclusive,
+    editable: false,
+    enableAutoResize: true,
+    enableAutoSizeColumns: true,
+    enableCellNavigation: false,
+    enableColumnPicker: true,
+    enableColumnReorder: true,
+    enableColumnResizeOnDoubleClick: true,
+    enableContextMenu: true,
+    enableExcelExport: true,
+    enableExport: false,
+    enableFilterTrimWhiteSpace: false,
+    enableGridMenu: true,
+    enableHeaderMenu: true,
+    enableEmptyDataWarningMessage: true,
+    emptyDataWarning: {
+        className: 'slick-empty-data-warning',
+        message: 'No data to display.',
+        messageKey: 'EMPTY_DATA_WARNING_MESSAGE',
+        hideFrozenLeftWarning: false,
+        hideFrozenRightWarning: false,
+        leftViewportMarginLeft: '40%',
+        rightViewportMarginLeft: '40%',
+        frozenLeftViewportMarginLeft: '0px',
+        frozenRightViewportMarginLeft: '40%',
+    },
+    enableMouseHoverHighlightRow: true,
+    enableSorting: true,
+    enableTextSelectionOnCells: true,
+    eventNamingStyle: EventNamingStyle.camelCase,
+    explicitInitialization: true,
+    excelExportOptions: {
+        addGroupIndentation: true,
+        exportWithFormatter: false,
+        filename: 'export',
+        format: FileType.xlsx,
+        groupingColumnHeaderTitle: 'Group By',
+        groupCollapsedSymbol: '⮞',
+        groupExpandedSymbol: '⮟',
+        groupingAggregatorRowText: '',
+        sanitizeDataExport: false,
+    },
+    exportOptions: {
+        delimiter: DelimiterType.comma,
+        exportWithFormatter: false,
+        filename: 'export',
+        format: FileType.csv,
+        groupingColumnHeaderTitle: 'Group By',
+        groupingAggregatorRowText: '',
+        sanitizeDataExport: false,
+        useUtf8WithBom: true
+    },
+    filterTypingDebounce: 0,
+    forceFitColumns: false,
+    frozenHeaderWidthCalcDifferential: 0,
+    gridMenu: {
+        dropSide: 'left',
+        commandLabels: {
+            clearAllFiltersCommandKey: 'CLEAR_ALL_FILTERS',
+            clearAllSortingCommandKey: 'CLEAR_ALL_SORTING',
+            clearFrozenColumnsCommandKey: 'CLEAR_PINNING',
+            exportCsvCommandKey: 'EXPORT_TO_CSV',
+            exportExcelCommandKey: 'EXPORT_TO_EXCEL',
+            exportTextDelimitedCommandKey: 'EXPORT_TO_TAB_DELIMITED',
+            refreshDatasetCommandKey: 'REFRESH_DATASET',
+            toggleFilterCommandKey: 'TOGGLE_FILTER_ROW',
+            togglePreHeaderCommandKey: 'TOGGLE_PRE_HEADER_ROW',
+        },
+        hideClearAllFiltersCommand: false,
+        hideClearAllSortingCommand: false,
+        hideClearFrozenColumnsCommand: true,
+        hideExportCsvCommand: false,
+        hideExportExcelCommand: false,
+        hideExportTextDelimitedCommand: true,
+        hideForceFitButton: false,
+        hideRefreshDatasetCommand: false,
+        hideSyncResizeButton: true,
+        hideToggleFilterCommand: false,
+        hideTogglePreHeaderCommand: false,
+        iconCssClass: 'fa fa-bars',
+        iconClearAllFiltersCommand: 'fa fa-filter text-danger',
+        iconClearAllSortingCommand: 'fa fa-unsorted text-danger',
+        iconClearFrozenColumnsCommand: 'fa fa-times',
+        iconExportCsvCommand: 'fa fa-download',
+        iconExportExcelCommand: 'fa fa-file-excel-o text-success',
+        iconExportTextDelimitedCommand: 'fa fa-download',
+        iconRefreshDatasetCommand: 'fa fa-refresh',
+        iconToggleFilterCommand: 'fa fa-random',
+        iconTogglePreHeaderCommand: 'fa fa-random',
+        menuWidth: 16,
+        resizeOnShowHeaderRow: true,
+        headerColumnValueExtractor: pickerHeaderColumnValueExtractor
+    },
+    headerMenu: {
+        autoAlign: true,
+        autoAlignOffset: 12,
+        minWidth: 140,
+        iconClearFilterCommand: 'fa fa-filter text-danger',
+        iconClearSortCommand: 'fa fa-unsorted',
+        iconFreezeColumns: 'fa fa-thumb-tack',
+        iconSortAscCommand: 'fa fa-sort-amount-asc',
+        iconSortDescCommand: 'fa fa-sort-amount-desc',
+        iconColumnHideCommand: 'fa fa-times',
+        iconColumnResizeByContentCommand: 'fa fa-arrows-h',
+        hideColumnResizeByContentCommand: false,
+        hideColumnHideCommand: false,
+        hideClearFilterCommand: false,
+        hideClearSortCommand: false,
+        hideFreezeColumnsCommand: true,
+        hideSortCommands: false
+    },
+    headerRowHeight: 35,
+    multiColumnSort: true,
+    numberedMultiColumnSort: true,
+    tristateMultiColumnSort: false,
+    sortColNumberInSeparateSpan: true,
+    suppressActiveCellChangeOnEdit: true,
+    pagination: {
+        pageSizes: [10, 15, 20, 25, 30, 40, 50, 75, 100],
+        pageSize: 25,
+        totalItems: 0
+    },
+    // technically speaking the Row Detail requires the process & viewComponent but we'll ignore it just to set certain options
+    rowDetailView: {
+        collapseAllOnSort: true,
+        cssClass: 'detail-view-toggle',
+        panelRows: 1,
+        keyPrefix: '__',
+        useRowClick: false,
+        useSimpleViewportCalc: true,
+        saveDetailViewOnScroll: false,
+    },
+    rowHeight: 35,
+    topPanelHeight: 35,
+    translationNamespaceSeparator: ':',
+    resetFilterSearchValueAfterOnBeforeCancellation: true,
+    resizeByContentOnlyOnFirstLoad: true,
+    resizeByContentOptions: {
+        alwaysRecalculateColumnWidth: false,
+        cellCharWidthInPx: 7.8,
+        cellPaddingWidthInPx: 14,
+        defaultRatioForStringType: 0.88,
+        formatterPaddingWidthInPx: 0,
+        maxItemToInspectCellContentWidth: 1000,
+        maxItemToInspectSingleColumnWidthByContent: 5000,
+        widthToRemoveFromExceededWidthReadjustment: 50,
+    },
+    treeDataOptions: {
+        exportIndentMarginLeft: 5,
+        exportIndentationLeadingChar: '͏͏͏͏͏͏͏͏͏·',
+    }
+};
+/**
+ * Value Extractor for both ColumnPicker & GridMenu Picker
+ * when using Column Header Grouping, we'll prefix the column group title
+ * else we'll simply return the column name title
+ */
+function pickerHeaderColumnValueExtractor(column) {
+    const headerGroup = column && column.columnGroup || '';
+    if (headerGroup) {
+        return headerGroup + ' - ' + column.name;
+    }
+    return column && column.name || '';
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"global-grid-options.js","sourceRoot":"","sources":["../../../../../src/app/modules/angular-slickgrid/global-grid-options.ts"],"names":[],"mappings":"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","sourcesContent":["import { Column, DelimiterType, EventNamingStyle, FileType, Filters, GridAutosizeColsMode, OperatorType, TreeDataOption } from '@slickgrid-universal/common';\r\nimport { GridOption, RowDetailView } from './models/index';\r\n\r\n/** Global Grid Options Defaults */\r\nexport const GlobalGridOptions: Partial<GridOption> = {\r\n  alwaysShowVerticalScroll: true,\r\n  autoEdit: false,\r\n  asyncEditorLoading: false,\r\n  autoFitColumnsOnFirstLoad: true,\r\n  autoResize: {\r\n    applyResizeToContainer: true,\r\n    calculateAvailableSizeBy: 'window',\r\n    bottomPadding: 20,\r\n    minHeight: 180,\r\n    minWidth: 300,\r\n    rightPadding: 0\r\n  },\r\n  cellHighlightCssClass: 'slick-cell-modified',\r\n  checkboxSelector: {\r\n    cssClass: 'slick-cell-checkboxsel'\r\n  },\r\n  columnPicker: {\r\n    fadeSpeed: 0,\r\n    hideForceFitButton: false,\r\n    hideSyncResizeButton: true,\r\n    headerColumnValueExtractor: pickerHeaderColumnValueExtractor\r\n  },\r\n  cellMenu: {\r\n    autoAdjustDrop: true,\r\n    autoAlignSide: true,\r\n    hideCloseButton: true,\r\n    hideCommandSection: false,\r\n    hideOptionSection: false,\r\n  },\r\n  contextMenu: {\r\n    autoAdjustDrop: true,\r\n    autoAlignSide: true,\r\n    hideCloseButton: true,\r\n    hideClearAllGrouping: false,\r\n    hideCollapseAllGroups: false,\r\n    hideCommandSection: false,\r\n    hideCopyCellValueCommand: false,\r\n    hideExpandAllGroups: false,\r\n    hideExportCsvCommand: false,\r\n    hideExportExcelCommand: false,\r\n    hideExportTextDelimitedCommand: true,\r\n    hideMenuOnScroll: true,\r\n    hideOptionSection: false,\r\n    iconCopyCellValueCommand: 'fa fa-clone',\r\n    iconExportCsvCommand: 'fa fa-download',\r\n    iconExportExcelCommand: 'fa fa-file-excel-o text-success',\r\n    iconExportTextDelimitedCommand: 'fa fa-download',\r\n  },\r\n  customFooterOptions: {\r\n    dateFormat: 'YYYY-MM-DD, hh:mm a',\r\n    hideRowSelectionCount: false,\r\n    hideTotalItemCount: false,\r\n    hideLastUpdateTimestamp: true,\r\n    footerHeight: 25,\r\n    leftContainerClass: 'col-xs-12 col-sm-5',\r\n    rightContainerClass: 'col-xs-6 col-sm-7',\r\n    metricSeparator: '|',\r\n    metricTexts: {\r\n      items: 'items',\r\n      itemsKey: 'ITEMS',\r\n      itemsSelected: 'items selected',\r\n      itemsSelectedKey: 'ITEMS_SELECTED',\r\n      of: 'of',\r\n      ofKey: 'OF',\r\n    }\r\n  },\r\n  dataView: {\r\n    syncGridSelection: true, // when enabled, this will preserve the row selection even after filtering/sorting/grouping\r\n    syncGridSelectionWithBackendService: false, // but disable it when using backend services\r\n  },\r\n  datasetIdPropertyName: 'id',\r\n  defaultFilter: Filters.input,\r\n  defaultBackendServiceFilterTypingDebounce: 500,\r\n  defaultColumnSortFieldId: 'id',\r\n  defaultFilterPlaceholder: '🔎︎',\r\n  defaultFilterRangeOperator: OperatorType.rangeInclusive,\r\n  editable: false,\r\n  enableAutoResize: true,\r\n  enableAutoSizeColumns: true,\r\n  enableCellNavigation: false,\r\n  enableColumnPicker: true,\r\n  enableColumnReorder: true,\r\n  enableColumnResizeOnDoubleClick: true,\r\n  enableContextMenu: true,\r\n  enableExcelExport: true, // Excel Export is the new default,\r\n  enableExport: false, // CSV/Text with Tab Delimited\r\n  enableFilterTrimWhiteSpace: false, // do we want to trim white spaces on all Filters?\r\n  enableGridMenu: true,\r\n  enableHeaderMenu: true,\r\n  enableEmptyDataWarningMessage: true,\r\n  emptyDataWarning: {\r\n    className: 'slick-empty-data-warning',\r\n    message: 'No data to display.',\r\n    messageKey: 'EMPTY_DATA_WARNING_MESSAGE',\r\n    hideFrozenLeftWarning: false,\r\n    hideFrozenRightWarning: false,\r\n    leftViewportMarginLeft: '40%',\r\n    rightViewportMarginLeft: '40%',\r\n    frozenLeftViewportMarginLeft: '0px',\r\n    frozenRightViewportMarginLeft: '40%',\r\n  },\r\n  enableMouseHoverHighlightRow: true,\r\n  enableSorting: true,\r\n  enableTextSelectionOnCells: true,\r\n  eventNamingStyle: EventNamingStyle.camelCase,\r\n  explicitInitialization: true,\r\n  excelExportOptions: {\r\n    addGroupIndentation: true,\r\n    exportWithFormatter: false,\r\n    filename: 'export',\r\n    format: FileType.xlsx,\r\n    groupingColumnHeaderTitle: 'Group By',\r\n    groupCollapsedSymbol: '⮞',\r\n    groupExpandedSymbol: '⮟',\r\n    groupingAggregatorRowText: '',\r\n    sanitizeDataExport: false,\r\n  },\r\n  exportOptions: {\r\n    delimiter: DelimiterType.comma,\r\n    exportWithFormatter: false,\r\n    filename: 'export',\r\n    format: FileType.csv,\r\n    groupingColumnHeaderTitle: 'Group By',\r\n    groupingAggregatorRowText: '',\r\n    sanitizeDataExport: false,\r\n    useUtf8WithBom: true\r\n  },\r\n  filterTypingDebounce: 0,\r\n  forceFitColumns: false,\r\n  frozenHeaderWidthCalcDifferential: 0,\r\n  gridMenu: {\r\n    dropSide: 'left',\r\n    commandLabels: {\r\n      clearAllFiltersCommandKey: 'CLEAR_ALL_FILTERS',\r\n      clearAllSortingCommandKey: 'CLEAR_ALL_SORTING',\r\n      clearFrozenColumnsCommandKey: 'CLEAR_PINNING',\r\n      exportCsvCommandKey: 'EXPORT_TO_CSV',\r\n      exportExcelCommandKey: 'EXPORT_TO_EXCEL',\r\n      exportTextDelimitedCommandKey: 'EXPORT_TO_TAB_DELIMITED',\r\n      refreshDatasetCommandKey: 'REFRESH_DATASET',\r\n      toggleFilterCommandKey: 'TOGGLE_FILTER_ROW',\r\n      togglePreHeaderCommandKey: 'TOGGLE_PRE_HEADER_ROW',\r\n    },\r\n    hideClearAllFiltersCommand: false,\r\n    hideClearAllSortingCommand: false,\r\n    hideClearFrozenColumnsCommand: true, // opt-in command\r\n    hideExportCsvCommand: false,\r\n    hideExportExcelCommand: false,\r\n    hideExportTextDelimitedCommand: true,\r\n    hideForceFitButton: false,\r\n    hideRefreshDatasetCommand: false,\r\n    hideSyncResizeButton: true,\r\n    hideToggleFilterCommand: false,\r\n    hideTogglePreHeaderCommand: false,\r\n    iconCssClass: 'fa fa-bars',\r\n    iconClearAllFiltersCommand: 'fa fa-filter text-danger',\r\n    iconClearAllSortingCommand: 'fa fa-unsorted text-danger',\r\n    iconClearFrozenColumnsCommand: 'fa fa-times',\r\n    iconExportCsvCommand: 'fa fa-download',\r\n    iconExportExcelCommand: 'fa fa-file-excel-o text-success',\r\n    iconExportTextDelimitedCommand: 'fa fa-download',\r\n    iconRefreshDatasetCommand: 'fa fa-refresh',\r\n    iconToggleFilterCommand: 'fa fa-random',\r\n    iconTogglePreHeaderCommand: 'fa fa-random',\r\n    menuWidth: 16,\r\n    resizeOnShowHeaderRow: true,\r\n    headerColumnValueExtractor: pickerHeaderColumnValueExtractor\r\n  },\r\n  headerMenu: {\r\n    autoAlign: true,\r\n    autoAlignOffset: 12,\r\n    minWidth: 140,\r\n    iconClearFilterCommand: 'fa fa-filter text-danger',\r\n    iconClearSortCommand: 'fa fa-unsorted',\r\n    iconFreezeColumns: 'fa fa-thumb-tack',\r\n    iconSortAscCommand: 'fa fa-sort-amount-asc',\r\n    iconSortDescCommand: 'fa fa-sort-amount-desc',\r\n    iconColumnHideCommand: 'fa fa-times',\r\n    iconColumnResizeByContentCommand: 'fa fa-arrows-h',\r\n    hideColumnResizeByContentCommand: false,\r\n    hideColumnHideCommand: false,\r\n    hideClearFilterCommand: false,\r\n    hideClearSortCommand: false,\r\n    hideFreezeColumnsCommand: true, // opt-in command\r\n    hideSortCommands: false\r\n  },\r\n  headerRowHeight: 35,\r\n  multiColumnSort: true,\r\n  numberedMultiColumnSort: true,\r\n  tristateMultiColumnSort: false,\r\n  sortColNumberInSeparateSpan: true,\r\n  suppressActiveCellChangeOnEdit: true,\r\n  pagination: {\r\n    pageSizes: [10, 15, 20, 25, 30, 40, 50, 75, 100],\r\n    pageSize: 25,\r\n    totalItems: 0\r\n  },\r\n  // technically speaking the Row Detail requires the process & viewComponent but we'll ignore it just to set certain options\r\n  rowDetailView: {\r\n    collapseAllOnSort: true,\r\n    cssClass: 'detail-view-toggle',\r\n    panelRows: 1,\r\n    keyPrefix: '__',\r\n    useRowClick: false,\r\n    useSimpleViewportCalc: true,\r\n    saveDetailViewOnScroll: false,\r\n  } as RowDetailView,\r\n  rowHeight: 35,\r\n  topPanelHeight: 35,\r\n  translationNamespaceSeparator: ':',\r\n  resetFilterSearchValueAfterOnBeforeCancellation: true,\r\n  resizeByContentOnlyOnFirstLoad: true,\r\n  resizeByContentOptions: {\r\n    alwaysRecalculateColumnWidth: false,\r\n    cellCharWidthInPx: 7.8,\r\n    cellPaddingWidthInPx: 14,\r\n    defaultRatioForStringType: 0.88,\r\n    formatterPaddingWidthInPx: 0,\r\n    maxItemToInspectCellContentWidth: 1000,\r\n    maxItemToInspectSingleColumnWidthByContent: 5000,\r\n    widthToRemoveFromExceededWidthReadjustment: 50,\r\n  },\r\n  treeDataOptions: {\r\n    exportIndentMarginLeft: 5,\r\n    exportIndentationLeadingChar: '͏͏͏͏͏͏͏͏͏·',\r\n  } as unknown as TreeDataOption\r\n};\r\n\r\n/**\r\n * Value Extractor for both ColumnPicker & GridMenu Picker\r\n * when using Column Header Grouping, we'll prefix the column group title\r\n * else we'll simply return the column name title\r\n */\r\nfunction pickerHeaderColumnValueExtractor(column: Column) {\r\n  const headerGroup = column && column.columnGroup || '';\r\n  if (headerGroup) {\r\n    return headerGroup + ' - ' + column.name;\r\n  }\r\n  return column && column.name || '';\r\n}\r\n"]}

package/{esm2015/app/modules/angular-slickgrid/index.js → esm2020/app/modules/angular-slickgrid/index.mjs}

@@ -1,8 +1,8 @@
 export * from '@slickgrid-universal/common';
 export { AngularUtilService, BsDropDownService, unsubscribeAllObservables } from './services/index';
-export { RowDetailViewExtension } from './extensions/index';
+export { SlickRowDetailView } from './extensions/index';
 // components & module
 export { SlickgridConfig } from './slickgrid-config';
 export { AngularSlickgridComponent } from './components/angular-slickgrid.component';
 export { AngularSlickgridModule } from './modules/angular-slickgrid.module';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9zcmMvYXBwL21vZHVsZXMvYW5ndWxhci1zbGlja2dyaWQvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyw2QkFBNkIsQ0FBQztBQUk1QyxPQUFPLEVBQUUsa0JBQWtCLEVBQUUsaUJBQWlCLEVBQUUseUJBQXlCLEVBQUUsTUFBTSxrQkFBa0IsQ0FBQztBQUNwRyxPQUFPLEVBQUUsc0JBQXNCLEVBQUUsTUFBTSxvQkFBb0IsQ0FBQztBQUU1RCxzQkFBc0I7QUFDdEIsT0FBTyxFQUFFLGVBQWUsRUFBRSxNQUFNLG9CQUFvQixDQUFDO0FBQ3JELE9BQU8sRUFBRSx5QkFBeUIsRUFBRSxNQUFNLDBDQUEwQyxDQUFDO0FBQ3JGLE9BQU8sRUFBRSxzQkFBc0IsRUFBRSxNQUFNLG9DQUFvQyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnQHNsaWNrZ3JpZC11bml2ZXJzYWwvY29tbW9uJztcclxuXHJcbi8vIFB1YmxpYyBjbGFzc2VzLlxyXG5leHBvcnQgeyBBbmd1bGFyQ29tcG9uZW50T3V0cHV0LCBBbmd1bGFyR3JpZEluc3RhbmNlLCBHcmlkT3B0aW9uLCBTbGlja0dyaWQsIFJvd0RldGFpbFZpZXcgfSBmcm9tICcuL21vZGVscy9pbmRleCc7XHJcbmV4cG9ydCB7IEFuZ3VsYXJVdGlsU2VydmljZSwgQnNEcm9wRG93blNlcnZpY2UsIHVuc3Vic2NyaWJlQWxsT2JzZXJ2YWJsZXMgfSBmcm9tICcuL3NlcnZpY2VzL2luZGV4JztcclxuZXhwb3J0IHsgUm93RGV0YWlsVmlld0V4dGVuc2lvbiB9IGZyb20gJy4vZXh0ZW5zaW9ucy9pbmRleCc7XHJcblxyXG4vLyBjb21wb25lbnRzICYgbW9kdWxlXHJcbmV4cG9ydCB7IFNsaWNrZ3JpZENvbmZpZyB9IGZyb20gJy4vc2xpY2tncmlkLWNvbmZpZyc7XHJcbmV4cG9ydCB7IEFuZ3VsYXJTbGlja2dyaWRDb21wb25lbnQgfSBmcm9tICcuL2NvbXBvbmVudHMvYW5ndWxhci1zbGlja2dyaWQuY29tcG9uZW50JztcclxuZXhwb3J0IHsgQW5ndWxhclNsaWNrZ3JpZE1vZHVsZSB9IGZyb20gJy4vbW9kdWxlcy9hbmd1bGFyLXNsaWNrZ3JpZC5tb2R1bGUnO1xyXG4iXX0=
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9zcmMvYXBwL21vZHVsZXMvYW5ndWxhci1zbGlja2dyaWQvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyw2QkFBNkIsQ0FBQztBQUk1QyxPQUFPLEVBQUUsa0JBQWtCLEVBQUUsaUJBQWlCLEVBQUUseUJBQXlCLEVBQUUsTUFBTSxrQkFBa0IsQ0FBQztBQUNwRyxPQUFPLEVBQUUsa0JBQWtCLEVBQUUsTUFBTSxvQkFBb0IsQ0FBQztBQUV4RCxzQkFBc0I7QUFDdEIsT0FBTyxFQUFFLGVBQWUsRUFBRSxNQUFNLG9CQUFvQixDQUFDO0FBQ3JELE9BQU8sRUFBRSx5QkFBeUIsRUFBRSxNQUFNLDBDQUEwQyxDQUFDO0FBQ3JGLE9BQU8sRUFBRSxzQkFBc0IsRUFBRSxNQUFNLG9DQUFvQyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnQHNsaWNrZ3JpZC11bml2ZXJzYWwvY29tbW9uJztcclxuXHJcbi8vIFB1YmxpYyBjbGFzc2VzLlxyXG5leHBvcnQgeyBBbmd1bGFyQ29tcG9uZW50T3V0cHV0LCBBbmd1bGFyR3JpZEluc3RhbmNlLCBHcmlkT3B0aW9uLCBTbGlja0dyaWQsIFJvd0RldGFpbFZpZXcgfSBmcm9tICcuL21vZGVscy9pbmRleCc7XHJcbmV4cG9ydCB7IEFuZ3VsYXJVdGlsU2VydmljZSwgQnNEcm9wRG93blNlcnZpY2UsIHVuc3Vic2NyaWJlQWxsT2JzZXJ2YWJsZXMgfSBmcm9tICcuL3NlcnZpY2VzL2luZGV4JztcclxuZXhwb3J0IHsgU2xpY2tSb3dEZXRhaWxWaWV3IH0gZnJvbSAnLi9leHRlbnNpb25zL2luZGV4JztcclxuXHJcbi8vIGNvbXBvbmVudHMgJiBtb2R1bGVcclxuZXhwb3J0IHsgU2xpY2tncmlkQ29uZmlnIH0gZnJvbSAnLi9zbGlja2dyaWQtY29uZmlnJztcclxuZXhwb3J0IHsgQW5ndWxhclNsaWNrZ3JpZENvbXBvbmVudCB9IGZyb20gJy4vY29tcG9uZW50cy9hbmd1bGFyLXNsaWNrZ3JpZC5jb21wb25lbnQnO1xyXG5leHBvcnQgeyBBbmd1bGFyU2xpY2tncmlkTW9kdWxlIH0gZnJvbSAnLi9tb2R1bGVzL2FuZ3VsYXItc2xpY2tncmlkLm1vZHVsZSc7XHJcbiJdfQ==

package/esm2020/app/modules/angular-slickgrid/models/angularGridInstance.interface.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYW5ndWxhckdyaWRJbnN0YW5jZS5pbnRlcmZhY2UuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9zcmMvYXBwL21vZHVsZXMvYW5ndWxhci1zbGlja2dyaWQvbW9kZWxzL2FuZ3VsYXJHcmlkSW5zdGFuY2UuaW50ZXJmYWNlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiIiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQge1xyXG4gIEJhY2tlbmRTZXJ2aWNlLFxyXG4gIEV4dGVuc2lvbkxpc3QsXHJcbiAgRXh0ZW5zaW9uU2VydmljZSxcclxuICBGaWx0ZXJTZXJ2aWNlLFxyXG4gIEdyaWRFdmVudFNlcnZpY2UsXHJcbiAgR3JpZFNlcnZpY2UsXHJcbiAgR3JpZFN0YXRlU2VydmljZSxcclxuICBHcm91cGluZ0FuZENvbHNwYW5TZXJ2aWNlLFxyXG4gIFBhZ2luYXRpb25TZXJ2aWNlLFxyXG4gIFJlc2l6ZXJTZXJ2aWNlLFxyXG4gIFNsaWNrRGF0YVZpZXcsXHJcbiAgU2xpY2tHcmlkLFxyXG4gIFNvcnRTZXJ2aWNlLFxyXG4gIFRyZWVEYXRhU2VydmljZVxyXG59IGZyb20gJ0BzbGlja2dyaWQtdW5pdmVyc2FsL2NvbW1vbic7XHJcblxyXG5leHBvcnQgaW50ZXJmYWNlIEFuZ3VsYXJHcmlkSW5zdGFuY2Uge1xyXG4gIC8qKiBTbGljayBEYXRhVmlldyBvYmplY3QgKi9cclxuICBkYXRhVmlldzogU2xpY2tEYXRhVmlldztcclxuXHJcbiAgLyoqIFNsaWNrIEdyaWQgb2JqZWN0ICovXHJcbiAgc2xpY2tHcmlkOiBTbGlja0dyaWQ7XHJcblxyXG4gIC8qKiBTbGlja0dyaWQgZXh0ZW5zaW9ucyAoZXh0ZXJuYWwgY29udHJvbHMvcGx1Z2lucykgKi9cclxuICBleHRlbnNpb25zOiBFeHRlbnNpb25MaXN0PGFueT47XHJcblxyXG4gIC8vIC0tXHJcbiAgLy8gTWV0aG9kc1xyXG4gIC8qKiBEaXNwb3NlIG9mIHRoZSBncmlkIGFuZCBvcHRpb25hbGx5IGVtcHR5IHRoZSBET00gZWxlbWVudCBncmlkIGNvbnRhaW5lciBhcyB3ZWxsICovXHJcbiAgZGVzdHJveTogKGVtcHR5RG9tRWxlbWVudENvbnRhaW5lcj86IGJvb2xlYW4pID0+IHZvaWQ7XHJcblxyXG4gIC8vIC0tXHJcbiAgLy8gU2VydmljZXNcclxuXHJcbiAgLyoqIEJhY2tlbmQgU2VydmljZSwgd2hlbiBhdmFpbGFibGUgKi9cclxuICBiYWNrZW5kU2VydmljZT86IEJhY2tlbmRTZXJ2aWNlO1xyXG5cclxuICAvKiogRXh0ZW5zaW9uIChQbHVnaW5zICYgQ29udHJvbHMpIFNlcnZpY2UgKi9cclxuICBleHRlbnNpb25TZXJ2aWNlOiBFeHRlbnNpb25TZXJ2aWNlO1xyXG5cclxuICAvKiogRmlsdGVyIFNlcnZpY2UgKi9cclxuICBmaWx0ZXJTZXJ2aWNlOiBGaWx0ZXJTZXJ2aWNlO1xyXG5cclxuICAvKiogR3JpZCBTZXJ2aWNlIChncmlkIGV4dHJhIGZ1bmN0aW9uYWxpdGllcykgKi9cclxuICBncmlkU2VydmljZTogR3JpZFNlcnZpY2U7XHJcblxyXG4gIC8qKiBHcmlkIEV2ZW50cyBTZXJ2aWNlICovXHJcbiAgZ3JpZEV2ZW50U2VydmljZTogR3JpZEV2ZW50U2VydmljZTtcclxuXHJcbiAgLyoqIEdyaWQgU3RhdGUgU2VydmljZSAqL1xyXG4gIGdyaWRTdGF0ZVNlcnZpY2U6IEdyaWRTdGF0ZVNlcnZpY2U7XHJcblxyXG4gIC8qKiBHcm91cGluZyAoYW5kIGNvbHNwYW4pIFNlcnZpY2UgKi9cclxuICBncm91cGluZ1NlcnZpY2U6IEdyb3VwaW5nQW5kQ29sc3BhblNlcnZpY2U7XHJcblxyXG4gIC8qKiBQYWdpbmF0aW9uIFNlcnZpY2UgKGFsbG93cyB5b3UgdG8gcHJvZ3JhbW1hdGljYWxseSBnbyB0byBmaXJzdC9sYXN0IHBhZ2UsIGV0Yy4uLikgKi9cclxuICBwYWdpbmF0aW9uU2VydmljZT86IFBhZ2luYXRpb25TZXJ2aWNlO1xyXG5cclxuICAvKiogUmVzaXplciBTZXJ2aWNlIChpbmNsdWRpbmcgYXV0by1yZXNpemUpICovXHJcbiAgcmVzaXplclNlcnZpY2U6IFJlc2l6ZXJTZXJ2aWNlO1xyXG5cclxuICAvKiogU29ydCBTZXJ2aWNlICovXHJcbiAgc29ydFNlcnZpY2U6IFNvcnRTZXJ2aWNlO1xyXG5cclxuICAvKiogVHJlZSBEYXRhIFZpZXcgU2VydmljZSAqL1xyXG4gIHRyZWVEYXRhU2VydmljZTogVHJlZURhdGFTZXJ2aWNlO1xyXG59XHJcbiJdfQ==

package/esm2020/app/modules/angular-slickgrid/modules/angular-slickgrid.module.mjs

@@ -0,0 +1,46 @@
+import { CommonModule } from '@angular/common';
+import { NgModule } from '@angular/core';
+import { TranslateModule } from '@ngx-translate/core';
+import { AngularSlickgridComponent } from './../components/angular-slickgrid.component';
+import { AngularUtilService } from '../services/angularUtil.service';
+import { BsDropDownService } from '../services/bsDropdown.service';
+import { ContainerService } from '../services/container.service';
+import * as i0 from "@angular/core";
+export class AngularSlickgridModule {
+    static forRoot(config = {}) {
+        return {
+            ngModule: AngularSlickgridModule,
+            providers: [
+                { provide: 'config', useValue: config },
+                { provide: 'externalService', useValue: null },
+                AngularUtilService,
+                BsDropDownService,
+                ContainerService,
+            ]
+        };
+    }
+}
+AngularSlickgridModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.1.0", ngImport: i0, type: AngularSlickgridModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+AngularSlickgridModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "13.1.0", ngImport: i0, type: AngularSlickgridModule, declarations: [AngularSlickgridComponent], imports: [CommonModule,
+        TranslateModule], exports: [AngularSlickgridComponent] });
+AngularSlickgridModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "13.1.0", ngImport: i0, type: AngularSlickgridModule, imports: [[
+            CommonModule,
+            TranslateModule
+        ]] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.1.0", ngImport: i0, type: AngularSlickgridModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [
+                        CommonModule,
+                        TranslateModule
+                    ],
+                    declarations: [
+                        AngularSlickgridComponent,
+                    ],
+                    exports: [
+                        AngularSlickgridComponent,
+                    ],
+                    entryComponents: [AngularSlickgridComponent]
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/app/modules/angular-slickgrid/services/angularUtil.service.mjs

@@ -0,0 +1,46 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+export class AngularUtilService {
+    constructor(compFactoryResolver, appRef, injector) {
+        this.compFactoryResolver = compFactoryResolver;
+        this.appRef = appRef;
+        this.injector = injector;
+    }
+    // ref https://hackernoon.com/angular-pro-tip-how-to-dynamically-create-components-in-body-ba200cc289e6
+    createAngularComponent(component) {
+        // Create a component reference from the component
+        const componentRef = this.compFactoryResolver
+            .resolveComponentFactory(component)
+            .create(this.injector);
+        // Attach component to the appRef so that it's inside the ng component tree
+        this.appRef.attachView(componentRef.hostView);
+        // Get DOM element from component
+        let domElem;
+        const viewRef = componentRef.hostView;
+        if (viewRef && Array.isArray(viewRef.rootNodes) && viewRef.rootNodes[0]) {
+            domElem = viewRef.rootNodes[0];
+        }
+        return { componentRef, domElement: domElem };
+    }
+    // ref https://hackernoon.com/angular-pro-tip-how-to-dynamically-create-components-in-body-ba200cc289e6
+    createAngularComponentAppendToDom(component, targetElement, clearTargetContent = false) {
+        const componentOutput = this.createAngularComponent(component);
+        // Append DOM element to the HTML element specified
+        if (targetElement && targetElement.appendChild) {
+            if (clearTargetContent && targetElement.innerHTML) {
+                targetElement.innerHTML = '';
+            }
+            targetElement.appendChild(componentOutput.domElement);
+        }
+        else {
+            document.body.appendChild(componentOutput.domElement); // when no target provided, we'll simply add it to the HTML Body
+        }
+        return componentOutput;
+    }
+}
+AngularUtilService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.1.0", ngImport: i0, type: AngularUtilService, deps: [{ token: i0.ComponentFactoryResolver }, { token: i0.ApplicationRef }, { token: i0.Injector }], target: i0.ɵɵFactoryTarget.Injectable });
+AngularUtilService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.1.0", ngImport: i0, type: AngularUtilService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.1.0", ngImport: i0, type: AngularUtilService, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i0.ComponentFactoryResolver }, { type: i0.ApplicationRef }, { type: i0.Injector }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/app/modules/angular-slickgrid/services/bsDropdown.service.mjs

@@ -0,0 +1,103 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+import * as i1 from "./angularUtil.service";
+// Boostrap dropdown service
+export class BsDropDownService {
+    constructor(angularUtilService) {
+        this.angularUtilService = angularUtilService;
+    }
+    get domElement() {
+        return this._domElement;
+    }
+    get domContainerElement() {
+        return this._domContainerElement;
+    }
+    get gridViewport() {
+        return $('.slick-viewport');
+    }
+    dispose() {
+        if (this._domElement && this._domElement.remove) {
+            this._domElement.remove();
+        }
+    }
+    dropContainerShow() {
+        if (this._domContainerElement && this._domContainerElement.show) {
+            this._domContainerElement.show();
+        }
+    }
+    render(dropdownParams) {
+        return new Promise((resolve) => {
+            const { component, args, parent, offsetTop, offsetLeft, offsetDropupBottom } = dropdownParams;
+            const cell = args.cell;
+            const row = args.row;
+            this._domContainerElement = $(`#myDrop-r${row}-c${cell}`);
+            if (this._domContainerElement) {
+                // hide the dropdown we created as a formatter Component, we'll redisplay it later
+                const cellPos = this._domContainerElement.offset();
+                const componentOutput = this.angularUtilService.createAngularComponent(component);
+                const componentInstance = componentOutput && componentOutput.componentRef && componentOutput.componentRef.instance;
+                if (componentInstance) {
+                    const myDropId = componentInstance.dropdownId || 'myDrop';
+                    const dropDownToggleId = componentInstance.dropDownToggleId || 'dropdownMenu1';
+                    this._domElement = $(`#${myDropId}`);
+                    if (this._domElement) {
+                        // make sure to remove any previous Action dropdown elements, to avoid having multiple element of the same on top of each other
+                        this.dispose();
+                        // assign the row data to the dropdown component instance
+                        Object.assign(componentInstance, { parent, row: args.row, dataContext: args.grid.getDataItem(args.row) });
+                        // use a delay to make sure Angular ran at least a full cycle and make sure it finished rendering the Component before using it
+                        setTimeout(() => {
+                            // create a new dropdown element
+                            this._domElement = $(componentOutput.domElement);
+                            const topPos = (cellPos && cellPos.top || 0) + 30 + (offsetTop || 0);
+                            const leftPos = (cellPos && cellPos.left || 0) + (offsetLeft || 0);
+                            this._domElement.appendTo('body');
+                            this._domElement.css('position', 'absolute');
+                            this._domElement.css('top', topPos);
+                            this._domElement.css('left', leftPos);
+                            $(`#${myDropId}`).addClass('open');
+                            $(`#${dropDownToggleId}`).hide();
+                            // check if it should drop Up or Down
+                            const offset = 35;
+                            const iElement = $('.dropdown-menu');
+                            const iElementWrapper = iElement.parent();
+                            const iElementWrapperOffset = iElementWrapper.offset() || {};
+                            const iElementWrapperOffsetTop = iElementWrapperOffset.top || iElementWrapper && iElementWrapper.length > 0 && iElementWrapper[0].offsetTop;
+                            const iElementHeight = iElement.height();
+                            const windowHeight = window.innerHeight;
+                            const shouldDropUp = (windowHeight - iElementHeight - offset) < iElementWrapperOffsetTop;
+                            let menuMarginTop = '0px';
+                            if (shouldDropUp) {
+                                const offsetBottom = offsetDropupBottom || 0;
+                                menuMarginTop = '-'.concat(`${iElementHeight + offset + offsetBottom + 5}`, 'px');
+                            }
+                            this._domElement.css({ 'margin-top': menuMarginTop });
+                            // set dropdown margin left according to the document width
+                            const parentOffset = iElementWrapperOffset.left;
+                            const leftMargin = parentOffset - $(document).width();
+                            this._domElement.css({ 'margin-left': (this._domElement.width() + leftMargin + 60) + 'px' });
+                            try {
+                                this._domElement.dropdown('show'); // required for Bootstrap 4 only
+                            }
+                            catch (e) {
+                                // Bootstrap 3 wil throw an error since that method doesn't exist, we can safely disregard it
+                            }
+                            this._domElement.on('hidden.bs.dropdown', () => this.dropContainerShow());
+                            // hide dropdown menu on grid scroll
+                            this.gridViewport.on('scroll', () => this.dispose());
+                            // hide on dropdown click
+                            this._domElement.on('click', () => this.dispose());
+                            resolve(true);
+                        });
+                    }
+                }
+            }
+        });
+    }
+}
+BsDropDownService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.1.0", ngImport: i0, type: BsDropDownService, deps: [{ token: i1.AngularUtilService }], target: i0.ɵɵFactoryTarget.Injectable });
+BsDropDownService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.1.0", ngImport: i0, type: BsDropDownService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.1.0", ngImport: i0, type: BsDropDownService, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i1.AngularUtilService }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"bsDropdown.service.js","sourceRoot":"","sources":["../../../../../../src/app/modules/angular-slickgrid/services/bsDropdown.service.ts"],"names":[],"mappings":"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","sourcesContent":["\r\nimport { Injectable } from '@angular/core';\r\nimport { AngularUtilService } from './angularUtil.service';\r\n\r\ninterface DropDownServiceParams {\r\n  /** the custom action formatter component that contains the dropdown */\r\n  component: any;\r\n\r\n  /** help to get the data context */\r\n  args: any;\r\n\r\n  /** parent container */\r\n  parent: any;\r\n\r\n  /** Offset bottom when using a Drop Up, if we need to reposition the dropdown component */\r\n  offsetDropupBottom?: number;\r\n\r\n  /** Offset left if we need to reposition the dropdown component */\r\n  offsetLeft?: number;\r\n\r\n  /** Offset top if we need to reposition the dropdown component */\r\n  offsetTop?: number;\r\n}\r\n\r\n// using external non-typed js libraries\r\ndeclare const $: any;\r\n\r\n// Boostrap dropdown service\r\n@Injectable()\r\nexport class BsDropDownService {\r\n  private _domContainerElement: any;\r\n  private _domElement: any;\r\n\r\n  constructor(private angularUtilService: AngularUtilService) { }\r\n\r\n  get domElement() {\r\n    return this._domElement;\r\n  }\r\n\r\n  get domContainerElement() {\r\n    return this._domContainerElement;\r\n  }\r\n\r\n  get gridViewport() {\r\n    return $('.slick-viewport');\r\n  }\r\n\r\n  dispose() {\r\n    if (this._domElement && this._domElement.remove) {\r\n      this._domElement.remove();\r\n    }\r\n  }\r\n\r\n  dropContainerShow() {\r\n    if (this._domContainerElement && this._domContainerElement.show) {\r\n      this._domContainerElement.show();\r\n    }\r\n  }\r\n\r\n  render(dropdownParams: DropDownServiceParams) {\r\n    return new Promise((resolve) => {\r\n      const { component, args, parent, offsetTop, offsetLeft, offsetDropupBottom } = dropdownParams;\r\n\r\n      const cell = args.cell;\r\n      const row = args.row;\r\n\r\n      this._domContainerElement = $(`#myDrop-r${row}-c${cell}`);\r\n\r\n      if (this._domContainerElement) {\r\n        // hide the dropdown we created as a formatter Component, we'll redisplay it later\r\n        const cellPos = this._domContainerElement.offset();\r\n\r\n        const componentOutput = this.angularUtilService.createAngularComponent(component);\r\n        const componentInstance = componentOutput && componentOutput.componentRef && componentOutput.componentRef.instance;\r\n\r\n        if (componentInstance) {\r\n          const myDropId = componentInstance.dropdownId || 'myDrop';\r\n          const dropDownToggleId = componentInstance.dropDownToggleId || 'dropdownMenu1';\r\n          this._domElement = $(`#${myDropId}`);\r\n\r\n          if (this._domElement) {\r\n            // make sure to remove any previous Action dropdown elements, to avoid having multiple element of the same on top of each other\r\n            this.dispose();\r\n\r\n            // assign the row data to the dropdown component instance\r\n            Object.assign(componentInstance, { parent, row: args.row, dataContext: args.grid.getDataItem(args.row) });\r\n\r\n            // use a delay to make sure Angular ran at least a full cycle and make sure it finished rendering the Component before using it\r\n            setTimeout(() => {\r\n              // create a new dropdown element\r\n              this._domElement = $(componentOutput.domElement);\r\n              const topPos = (cellPos && cellPos.top || 0) + 30 + (offsetTop || 0);\r\n              const leftPos = (cellPos && cellPos.left || 0) + (offsetLeft || 0);\r\n              this._domElement.appendTo('body');\r\n              this._domElement.css('position', 'absolute');\r\n              this._domElement.css('top', topPos);\r\n              this._domElement.css('left', leftPos);\r\n              $(`#${myDropId}`).addClass('open');\r\n              $(`#${dropDownToggleId}`).hide();\r\n\r\n              // check if it should drop Up or Down\r\n              const offset = 35;\r\n              const iElement = $('.dropdown-menu');\r\n              const iElementWrapper = iElement.parent();\r\n              const iElementWrapperOffset = iElementWrapper.offset() || {};\r\n              const iElementWrapperOffsetTop = iElementWrapperOffset.top || iElementWrapper && iElementWrapper.length > 0 && iElementWrapper[0].offsetTop;\r\n              const iElementHeight = iElement.height();\r\n              const windowHeight = window.innerHeight;\r\n              const shouldDropUp = (windowHeight - iElementHeight - offset) < iElementWrapperOffsetTop;\r\n              let menuMarginTop = '0px';\r\n              if (shouldDropUp) {\r\n                const offsetBottom = offsetDropupBottom || 0;\r\n                menuMarginTop = '-'.concat(`${iElementHeight + offset + offsetBottom + 5}`, 'px');\r\n              }\r\n              this._domElement.css({ 'margin-top': menuMarginTop });\r\n\r\n              // set dropdown margin left according to the document width\r\n              const parentOffset = iElementWrapperOffset.left;\r\n              const leftMargin = parentOffset - $(document).width();\r\n              this._domElement.css({ 'margin-left': (this._domElement.width() + leftMargin + 60) + 'px' });\r\n\r\n              try {\r\n                this._domElement.dropdown('show'); // required for Bootstrap 4 only\r\n              } catch (e) {\r\n                // Bootstrap 3 wil throw an error since that method doesn't exist, we can safely disregard it\r\n              }\r\n\r\n              this._domElement.on('hidden.bs.dropdown', () => this.dropContainerShow());\r\n\r\n              // hide dropdown menu on grid scroll\r\n              this.gridViewport.on('scroll', () => this.dispose());\r\n\r\n              // hide on dropdown click\r\n              this._domElement.on('click', () => this.dispose());\r\n              resolve(true);\r\n            });\r\n          }\r\n        }\r\n      }\r\n    });\r\n  }\r\n}\r\n"]}

package/esm2020/app/modules/angular-slickgrid/services/container.service.mjs

@@ -0,0 +1,26 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+export class ContainerService {
+    constructor() {
+        this.dependencies = [];
+    }
+    get(key) {
+        const dependency = this.dependencies.find(dep => dep.key === key);
+        if (dependency?.instance) {
+            return dependency.instance;
+        }
+        return null;
+    }
+    registerInstance(key, instance) {
+        const dependency = this.dependencies.some(dep => dep.key === key);
+        if (!dependency) {
+            this.dependencies.push({ key, instance });
+        }
+    }
+}
+ContainerService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.1.0", ngImport: i0, type: ContainerService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+ContainerService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.1.0", ngImport: i0, type: ContainerService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.1.0", ngImport: i0, type: ContainerService, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return []; } });
+//# sourceMappingURL=data:application/json;base64,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