@coolon/angular-ui-powerups 13.1.7 → 13.3.0

package/esm2020/lib/components/tables/column/column-model.mjs

@@ -0,0 +1,180 @@
+import { __decorate, __metadata } from "tslib";
+import { ComponentRef } from "@angular/core";
+import { DelegatingValueModel, Functions, GarbageCollector } from "@coolon/pectin";
+import { lang, assert, Stringy } from "@coolon/typescript-utilities";
+import { Memoize } from "@typescript-plus/fast-memoize-decorator";
+import { CellHeaderPortalRef } from "../renderer/cell-portal-ref";
+import { DefaultHeaderCellRendererComponent } from "../renderer/default-header-cell-renderer/default-header-cell-renderer.component";
+import { ColumnTextSearchFormatter } from "../search/column-text-search-formatter";
+const noop = () => {
+};
+class ColumnTextSearchWrapper extends ColumnTextSearchFormatter.Delegate {
+    constructor() {
+        super(...arguments);
+        this._map = Functions.identity;
+    }
+    initialise(injector) {
+        if (this._delegate instanceof ColumnTextSearchFormatter.Delegate) {
+            this._delegate.initialise(injector);
+        }
+    }
+    format(row) {
+        let value = this._map(row);
+        let result = this._delegate ? this._delegate.format(value) : "";
+        console.log({ format: row, value, text: result });
+        return result;
+    }
+    setDelegate(formatter, mapper) {
+        this._delegate = formatter;
+        this._map = mapper ?? Functions.identity;
+    }
+}
+export class ColumnModel extends GarbageCollector {
+    constructor(columnId, textPropertiesProvider) {
+        super();
+        this.columnId = columnId;
+        this.textPropertiesProvider = textPropertiesProvider;
+        this._enableRowSelection = true;
+        this._flex = false;
+        this._defaultVisibility$ = this.registerDisposable(new DelegatingValueModel().withDefault(true));
+        this._visible$ = this.registerDisposable(new DelegatingValueModel().withDefault(this._defaultVisibility$));
+        this.textSearchDelegate = new ColumnTextSearchWrapper();
+        this.installHeaderRenderer();
+        this.dasherisedColumnId = Stringy.from(columnId).dasherize().toString();
+    }
+    installHeaderRenderer() {
+        this.cellHeaderRenderer(DefaultHeaderCellRendererComponent, (component, column) => {
+            component.headerText = column.getHeaderText();
+        });
+    }
+    getHeaderText() {
+        return this.getColumnTextProperties()?.headerText() || this.getDefaultHeaderText();
+    }
+    isVisible() {
+        return this.visible$.value;
+    }
+    get visible$() {
+        return this._visible$.readonly;
+    }
+    visibleWhile(visible) {
+        this._visible$.setDelegate(visible);
+        return this;
+    }
+    setDefaultVisibility(visible) {
+        this._defaultVisibility$.setDelegate(visible);
+    }
+    getDefaultHeaderText() {
+        return this.columnId;
+    }
+    getColumnTextProperties() {
+        return this._columnTextProperties || this.textPropertiesProvider();
+    }
+    /**
+     * @deprecated use #columnTextProperties instead
+     * @param columnTextProperties
+     */
+    textProperties(columnTextProperties) {
+        return this.columnTextProperties(columnTextProperties);
+    }
+    columnTextProperties(columnTextProperties) {
+        this._columnTextProperties = columnTextProperties;
+        return this;
+    }
+    getSearchTextFor(row) {
+        return this.textSearchDelegate.format(row);
+    }
+    configureColumnTextSearch(formatter, mapper) {
+        assert.notNil(formatter);
+        console.log({ col: this.columnId, formatter });
+        this.textSearchDelegate.setDelegate(formatter, mapper);
+    }
+    configureHeaderRenderer(config) {
+        this._columnHeaderPortalRef = config;
+    }
+    configureCellRenderer(config) {
+        this._cellRendererPortalRef = config;
+    }
+    configureCellEditor(cellEditor) {
+        this._cellEditorPortalRef = cellEditor;
+    }
+    cellHeaderRenderer(componentType, initialiser) {
+        this.configureHeaderRenderer(new CellHeaderPortalRef(componentType, initialiser));
+        return this;
+    }
+    flex(flex = true) {
+        this._flex = flex;
+    }
+    isFlex() {
+        return this._flex;
+    }
+    hasEditorPortal() {
+        return !!this._cellEditorPortalRef;
+    }
+    attachHeaderCell(host) {
+        this._columnHeaderPortalRef.initialiseHost(host, this);
+    }
+    attachCell(host) {
+        this._cellRendererPortalRef.initialiseHost(host, this);
+        if (this.hasEditorPortal()) {
+            this._cellEditorPortalRef.initialiseHost(host, this);
+        }
+    }
+    onHeaderAttached(host, ref) {
+        const component = this.getComponent(ref);
+        this._columnHeaderPortalRef.onPortalAttached(host, component);
+    }
+    onRendererAttached(host, ref) {
+        const component = this.getComponentOrEmbeddedView(ref);
+        this._cellRendererPortalRef.onPortalAttached(host, component);
+    }
+    // @Trace()
+    onEditorAttached(host, ref) {
+        this._cellEditorPortalRef.onPortalAttached(host, this.getComponent(ref));
+    }
+    updatePortalContent(host) {
+        this._cellRendererPortalRef.pushState(host);
+    }
+    _selectRowOnClick(selectRowOnClick) {
+        this._enableRowSelection = selectRowOnClick;
+        return this;
+    }
+    isRowSelectionEnabled() {
+        return this._enableRowSelection;
+    }
+    getComponent(ref) {
+        if (ref instanceof ComponentRef) {
+            return ref.instance;
+        }
+        else {
+            console.error("headers only support component portals, got", ref);
+            lang.illegalState(`headers only support component portals, got ${ref}`);
+        }
+    }
+    getComponentOrEmbeddedView(ref) {
+        if (ref instanceof ComponentRef) {
+            return ref.instance;
+        }
+        else {
+            return ref;
+        }
+    }
+    initialise(injector) {
+        this.textSearchDelegate.initialise(injector);
+    }
+}
+__decorate([
+    Memoize(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", String)
+], ColumnModel.prototype, "getHeaderText", null);
+__decorate([
+    Memoize(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", Object)
+], ColumnModel.prototype, "getColumnTextProperties", null);
+(function (ColumnModel) {
+    ColumnModel.CELL_RENDERER_COMPONENT_ROW_CACHE = Symbol('aup-cell-renderer:row-data-cache');
+})(ColumnModel || (ColumnModel = {}));
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"column-model.js","sourceRoot":"","sources":["../../../../../../../../libs/angular-ui-powerups/src/lib/components/tables/column/column-model.ts"],"names":[],"mappings":"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","sourcesContent":["import { ComponentType } from \"@angular/cdk/overlay\";\nimport { CdkPortalOutletAttachedRef } from \"@angular/cdk/portal/portal-directives\";\nimport { ComponentRef, Injector } from \"@angular/core\";\nimport { Command, DelegatingValueModel, Functions, GarbageCollector, Trace, ValueModel } from \"@coolon/pectin\";\nimport { lang, assert, Stringy } from \"@coolon/typescript-utilities\";\nimport { Memoize } from \"@typescript-plus/fast-memoize-decorator\";\nimport { EditSession } from \"../editor/edit-session\";\nimport { CellEditorPortalRef, CellHeaderPortalRef, CellRendererPortalRef } from \"../renderer/cell-portal-ref\";\nimport {\n  DefaultHeaderCellRendererComponent\n} from \"../renderer/default-header-cell-renderer/default-header-cell-renderer.component\";\nimport { TableCellComponent } from \"../renderer/table-cell/table-cell.component\";\nimport { TableHeaderCellComponent } from \"../renderer/table-header-cell/table-header-cell.component\";\nimport { ColumnTextSearchFormatter } from \"../search/column-text-search-formatter\";\nimport { ColumnTextProperties } from \"./column-text-properties\";\n\n\nconst noop = () => {\n};\n\nexport interface RowData<Row> {\n  row: Row;\n  editSession?: EditSession<Row>;\n  editRowCommand: Command<void>;\n}\n\nexport type OnComponentInit<C> = (component: C) => void;\n\nexport interface CellRendererOptions<Row, E> {\n  onComponentInit?: (component: E) => void;\n  onRowUpdate?: (component: E, row: Row) => void;\n}\n\n\nexport interface MutableCellRendererOptions<Row, E, P extends keyof Row> extends CellRendererOptions<Row, E> {\n  onValueEdit: (row: Row, is: Row[P], was: Row[P]) => void;\n}\n\nclass ColumnTextSearchWrapper<Row> extends ColumnTextSearchFormatter.Delegate<Row>{\n  private _delegate: ColumnTextSearchFormatter<any>;\n  private _map: (row:Row) => any = Functions.identity;\n\n  initialise(injector: Injector) {\n    if (this._delegate instanceof ColumnTextSearchFormatter.Delegate) {\n      this._delegate.initialise(injector);\n    }\n  }\n\n  format(row: Row): string {\n    let value = this._map(row);\n    let result = this._delegate ? this._delegate.format(value) : \"\";\n    console.log({format: row, value, text:result})\n    return result;\n  }\n\n  setDelegate<T>(formatter: ColumnTextSearchFormatter<T>, mapper?: (row:Row) => T) {\n    this._delegate = formatter;\n    this._map = mapper ?? Functions.identity;\n  }\n}\n\nexport class ColumnModel<Row> extends GarbageCollector {\n\n  private _columnTextProperties: ColumnTextProperties;\n\n  private _columnHeaderPortalRef: CellHeaderPortalRef<Row, any>;\n  private _cellRendererPortalRef: CellRendererPortalRef<Row, any>;\n  private _cellEditorPortalRef: CellEditorPortalRef<Row, any>;\n\n  private _enableRowSelection = true;\n  private _flex = false;\n\n  private _defaultVisibility$ = this.registerDisposable(new DelegatingValueModel<boolean>().withDefault(true));\n  private _visible$ = this.registerDisposable(new DelegatingValueModel<boolean>().withDefault(this._defaultVisibility$));\n  readonly dasherisedColumnId: string;\n\n  private readonly textSearchDelegate = new ColumnTextSearchWrapper<Row>();\n\n  constructor(readonly columnId: string, private textPropertiesProvider: ColumnModel.TextPropertiesProvider) {\n    super();\n    this.installHeaderRenderer();\n    this.dasherisedColumnId = Stringy.from(columnId).dasherize().toString();\n  }\n\n  protected installHeaderRenderer() {\n    this.cellHeaderRenderer(DefaultHeaderCellRendererComponent, (component, column) => {\n      component.headerText = column.getHeaderText();\n    });\n  }\n\n  @Memoize()\n  getHeaderText(): string {\n    return this.getColumnTextProperties()?.headerText() || this.getDefaultHeaderText();\n  }\n\n  isVisible() {\n    return this.visible$.value;\n  }\n\n  get visible$() {\n    return this._visible$.readonly;\n  }\n\n  visibleWhile(visible: ValueModel<boolean>): this {\n    this._visible$.setDelegate(visible);\n    return this;\n  }\n\n  protected setDefaultVisibility(visible: ValueModel<boolean>) {\n    this._defaultVisibility$.setDelegate(visible);\n  }\n\n  protected getDefaultHeaderText() {\n    return this.columnId;\n  }\n\n  @Memoize()\n  getColumnTextProperties(): ColumnTextProperties {\n    return this._columnTextProperties || this.textPropertiesProvider();\n  }\n\n  /**\n   * @deprecated use #columnTextProperties instead\n   * @param columnTextProperties\n   */\n  textProperties(columnTextProperties: ColumnTextProperties): this {\n    return this.columnTextProperties(columnTextProperties);\n  }\n\n  columnTextProperties(columnTextProperties: ColumnTextProperties): this {\n    this._columnTextProperties = columnTextProperties;\n    return this;\n  }\n\n  getSearchTextFor(row: Row): string {\n      return this.textSearchDelegate.format(row)\n  }\n\n  protected configureColumnTextSearch(formatter: ColumnTextSearchFormatter<Row>)\n  protected configureColumnTextSearch<T>(formatter: ColumnTextSearchFormatter<T>, mapper: (row:Row) => T)\n  protected configureColumnTextSearch(formatter: ColumnTextSearchFormatter<any>, mapper?: (row:Row) => any) {\n    assert.notNil(formatter);\n    console.log({col: this.columnId, formatter});\n    this.textSearchDelegate.setDelegate(formatter, mapper);\n  }\n\n\n  protected configureHeaderRenderer<C>(config: CellHeaderPortalRef<Row, any>): void {\n    this._columnHeaderPortalRef = config;\n  }\n\n  protected configureCellRenderer<C>(config: CellRendererPortalRef<Row, any>): void {\n    this._cellRendererPortalRef = config;\n  }\n\n  protected configureCellEditor<E>(cellEditor: CellEditorPortalRef<Row, E>): void {\n    this._cellEditorPortalRef = cellEditor;\n  }\n\n  cellHeaderRenderer<C>(componentType: ComponentType<C>, initialiser: (component: C, column: ColumnModel<Row>) => void): this {\n    this.configureHeaderRenderer(new CellHeaderPortalRef<Row, C>(componentType, initialiser));\n    return this;\n  }\n\n  flex(flex = true) {\n    this._flex = flex;\n  }\n\n  isFlex() {\n    return this._flex;\n  }\n\n  hasEditorPortal() {\n    return !!this._cellEditorPortalRef;\n  }\n\n  attachHeaderCell(host: any) {\n    this._columnHeaderPortalRef.initialiseHost(host, this);\n  }\n\n  attachCell(host: any) {\n    this._cellRendererPortalRef.initialiseHost(host, this);\n    if (this.hasEditorPortal()) {\n      this._cellEditorPortalRef.initialiseHost(host, this);\n    }\n  }\n\n  onHeaderAttached(host: TableHeaderCellComponent, ref: CdkPortalOutletAttachedRef) {\n    const component = this.getComponent(ref);\n    this._columnHeaderPortalRef.onPortalAttached(host, component);\n  }\n\n  onRendererAttached(host: TableCellComponent<Row>, ref: CdkPortalOutletAttachedRef) {\n    const component = this.getComponentOrEmbeddedView(ref);\n    this._cellRendererPortalRef.onPortalAttached(host, component);\n  }\n\n  // @Trace()\n  onEditorAttached(host: TableCellComponent<Row>, ref: CdkPortalOutletAttachedRef) {\n    this._cellEditorPortalRef.onPortalAttached(host, this.getComponent(ref));\n  }\n\n  updatePortalContent(host: TableCellComponent<Row>) {\n    this._cellRendererPortalRef.pushState(host);\n  }\n\n  protected _selectRowOnClick(selectRowOnClick: boolean): this {\n    this._enableRowSelection = selectRowOnClick;\n    return this;\n  }\n\n  isRowSelectionEnabled(): boolean {\n    return this._enableRowSelection;\n  }\n\n  protected getComponent(ref: CdkPortalOutletAttachedRef): any {\n    if (ref instanceof ComponentRef) {\n      return ref.instance;\n    } else {\n      console.error(\"headers only support component portals, got\", ref);\n      lang.illegalState(`headers only support component portals, got ${ref}`)\n    }\n  }\n  protected getComponentOrEmbeddedView(ref: CdkPortalOutletAttachedRef): any {\n    if (ref instanceof ComponentRef) {\n      return ref.instance;\n    } else {\n      return ref;\n    }\n  }\n\n  initialise(injector: Injector) {\n    this.textSearchDelegate.initialise(injector);\n  }\n}\n\nexport namespace ColumnModel {\n  export const CELL_RENDERER_COMPONENT_ROW_CACHE = Symbol('aup-cell-renderer:row-data-cache');\n  export type TextPropertiesProvider = () => ColumnTextProperties\n}\n\n"]}

package/esm2020/lib/components/tables/column/column-template/column-template.directive.mjs

@@ -0,0 +1,35 @@
+import { Directive, Input, TemplateRef, ViewContainerRef } from '@angular/core';
+import { assert } from '@coolon/pectin';
+import { AbstractTableComponent } from '../../abstract-table.component';
+import * as i0 from "@angular/core";
+import * as i1 from "../../abstract-table.component";
+export class ColumnTemplateDirective {
+    constructor(host, templateRef, viewContainer) {
+        this.host = host;
+        this.templateRef = templateRef;
+        this.viewContainer = viewContainer;
+        this.aupColumnTemplateFillCell = false;
+        this.aupColumnTemplateAutoPadChild = undefined;
+    }
+    ngOnInit() {
+        assert.isTruthy(this.aupColumnTemplateColumnId);
+        this.host.registerColumnTemplate(this.aupColumnTemplateColumnId, this.templateRef, this.viewContainer, this.aupColumnTemplateFillCell, this.aupColumnTemplateAutoPadChild ?? this.aupColumnTemplateFillCell);
+    }
+}
+ColumnTemplateDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.3", ngImport: i0, type: ColumnTemplateDirective, deps: [{ token: i1.AbstractTableComponent }, { token: i0.TemplateRef }, { token: i0.ViewContainerRef }], target: i0.ɵɵFactoryTarget.Directive });
+ColumnTemplateDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "12.0.0", version: "13.2.3", type: ColumnTemplateDirective, selector: "[aupColumnTemplate]", inputs: { aupColumnTemplate: "aupColumnTemplate", aupColumnTemplateColumnId: "aupColumnTemplateColumnId", aupColumnTemplateFillCell: "aupColumnTemplateFillCell", aupColumnTemplateAutoPadChild: "aupColumnTemplateAutoPadChild" }, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.3", ngImport: i0, type: ColumnTemplateDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[aupColumnTemplate]'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.AbstractTableComponent }, { type: i0.TemplateRef }, { type: i0.ViewContainerRef }]; }, propDecorators: { aupColumnTemplate: [{
+                type: Input
+            }], aupColumnTemplateColumnId: [{
+                type: Input
+            }], aupColumnTemplateFillCell: [{
+                type: Input
+            }], aupColumnTemplateAutoPadChild: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/components/tables/column/column-text-properties.mjs

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

package/esm2020/lib/components/tables/column/custom-template-column-model.mjs

@@ -0,0 +1,16 @@
+import { TemplateCellRendererPortalRef } from "../renderer/cell-portal-ref";
+import { ColumnModel } from "./column-model";
+export class CustomTemplateColumnModel extends ColumnModel {
+    constructor(columnId, defaults) {
+        super(columnId, defaults);
+        this.config = new TemplateCellRendererPortalRef();
+        this.configureCellRenderer(this.config);
+    }
+    setTemplate(templateRef, viewContainer, fillCell, padChild) {
+        this.config.registerPortal(templateRef, viewContainer, fillCell, padChild);
+    }
+    selectRowOnClick(selectOnRowClick) {
+        return this._selectRowOnClick(selectOnRowClick);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/components/tables/column/custom-value-column-model.mjs

@@ -0,0 +1,37 @@
+import { isFunction } from "lodash";
+import { ComponentCellRendererPortalRef } from "../renderer/cell-portal-ref";
+import { DefaultCellRendererComponent } from "../renderer/default-cell-renderer/default-cell-renderer.component";
+import { ColumnTextSearchFormatter } from "../search/column-text-search-formatter";
+import { EnableCellTextSearch } from "../search/enable-cell-text-search.decorator";
+import { ColumnModel } from "./column-model";
+export class CustomValueColumnModel extends ColumnModel {
+    constructor(columnId, defaults, getValue) {
+        super(columnId, defaults);
+        this.getValue = getValue;
+        this.cellRenderer(DefaultCellRendererComponent);
+    }
+    cellRenderer(componentType, onComponentInitOrOptions) {
+        this.configureColumnTextSearch(EnableCellTextSearch.getFormatter(componentType, () => new ColumnTextSearchFormatter.Null()), row => this.getValue(row));
+        this.configureCellRenderer(new ComponentCellRendererPortalRef(componentType, (component, rowData, firstTime) => {
+            if (firstTime) {
+                if (isFunction(onComponentInitOrOptions)) {
+                    onComponentInitOrOptions(component);
+                }
+                else {
+                    if (isFunction(onComponentInitOrOptions?.onComponentInit)) {
+                        onComponentInitOrOptions.onComponentInit(component);
+                    }
+                }
+            }
+            component.value = this.getValue(rowData.row);
+            if (!isFunction(onComponentInitOrOptions) && isFunction(onComponentInitOrOptions?.onRowUpdate)) {
+                onComponentInitOrOptions.onRowUpdate(component, rowData.row);
+            }
+        }));
+        return this;
+    }
+    selectRowOnClick(selectOnRowClick) {
+        return this._selectRowOnClick(selectOnRowClick);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY3VzdG9tLXZhbHVlLWNvbHVtbi1tb2RlbC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uL2xpYnMvYW5ndWxhci11aS1wb3dlcnVwcy9zcmMvbGliL2NvbXBvbmVudHMvdGFibGVzL2NvbHVtbi9jdXN0b20tdmFsdWUtY29sdW1uLW1vZGVsLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUVBLE9BQU8sRUFBRSxVQUFVLEVBQUUsTUFBTSxRQUFRLENBQUM7QUFDcEMsT0FBTyxFQUFFLDhCQUE4QixFQUFFLE1BQU0sNkJBQTZCLENBQUM7QUFDN0UsT0FBTyxFQUFFLDRCQUE0QixFQUFFLE1BQU0sbUVBQW1FLENBQUM7QUFDakgsT0FBTyxFQUFFLHlCQUF5QixFQUFFLE1BQU0sd0NBQXdDLENBQUM7QUFDbkYsT0FBTyxFQUFFLG9CQUFvQixFQUFFLE1BQU0sNkNBQTZDLENBQUM7QUFDbkYsT0FBTyxFQUF1QixXQUFXLEVBQW1CLE1BQU0sZ0JBQWdCLENBQUM7QUFFbkYsTUFBTSxPQUFPLHNCQUErQixTQUFRLFdBQWdCO0lBRWxFLFlBQVksUUFBZ0IsRUFBRSxRQUE0QyxFQUFVLFFBQXlCO1FBQzNHLEtBQUssQ0FBQyxRQUFRLEVBQUUsUUFBUSxDQUFDLENBQUM7UUFEd0QsYUFBUSxHQUFSLFFBQVEsQ0FBaUI7UUFFM0csSUFBSSxDQUFDLFlBQVksQ0FBQyw0QkFBNEIsQ0FBQyxDQUFDO0lBQ2xELENBQUM7SUFFRCxZQUFZLENBQWtDLGFBQStCLEVBQUUsd0JBQTJFO1FBQ3hKLElBQUksQ0FBQyx5QkFBeUIsQ0FDNUIsb0JBQW9CLENBQUMsWUFBWSxDQUFDLGFBQWEsRUFBRSxHQUFHLEVBQUUsQ0FBQyxJQUFJLHlCQUF5QixDQUFDLElBQUksRUFBRSxDQUFDLEVBQzVGLEdBQUcsQ0FBQyxFQUFFLENBQUMsSUFBSSxDQUFDLFFBQVEsQ0FBQyxHQUFHLENBQUMsQ0FDMUIsQ0FBQztRQUNGLElBQUksQ0FBQyxxQkFBcUIsQ0FBQyxJQUFJLDhCQUE4QixDQUFDLGFBQWEsRUFBRSxDQUFDLFNBQVMsRUFBRSxPQUFPLEVBQUUsU0FBUyxFQUFFLEVBQUU7WUFDN0csSUFBSSxTQUFTLEVBQUU7Z0JBQ2IsSUFBSSxVQUFVLENBQUMsd0JBQXdCLENBQUMsRUFBRTtvQkFDeEMsd0JBQXdCLENBQUMsU0FBUyxDQUFDLENBQUM7aUJBQ3JDO3FCQUFNO29CQUNMLElBQUksVUFBVSxDQUFDLHdCQUF3QixFQUFFLGVBQWUsQ0FBQyxFQUFFO3dCQUN6RCx3QkFBd0IsQ0FBQyxlQUFlLENBQUMsU0FBUyxDQUFDLENBQUM7cUJBQ3JEO2lCQUNGO2FBQ0Y7WUFDRCxTQUFTLENBQUMsS0FBSyxHQUFHLElBQUksQ0FBQyxRQUFRLENBQUMsT0FBTyxDQUFDLEdBQUcsQ0FBQyxDQUFDO1lBRTdDLElBQUksQ0FBQyxVQUFVLENBQUMsd0JBQXdCLENBQUMsSUFBSSxVQUFVLENBQUMsd0JBQXdCLEVBQUUsV0FBVyxDQUFDLEVBQUU7Z0JBQzlGLHdCQUF3QixDQUFDLFdBQVcsQ0FBQyxTQUFTLEVBQUUsT0FBTyxDQUFDLEdBQUcsQ0FBQyxDQUFDO2FBQzlEO1FBQ0gsQ0FBQyxDQUFDLENBQUMsQ0FBQztRQUNKLE9BQU8sSUFBSSxDQUFDO0lBQ2QsQ0FBQztJQUVNLGdCQUFnQixDQUFDLGdCQUF5QjtRQUMvQyxPQUFPLElBQUksQ0FBQyxpQkFBaUIsQ0FBQyxnQkFBZ0IsQ0FBQyxDQUFDO0lBQ2xELENBQUM7Q0FFRiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IENvbXBvbmVudFR5cGUgfSBmcm9tIFwiQGFuZ3VsYXIvY2RrL292ZXJsYXlcIjtcblxuaW1wb3J0IHsgaXNGdW5jdGlvbiB9IGZyb20gXCJsb2Rhc2hcIjtcbmltcG9ydCB7IENvbXBvbmVudENlbGxSZW5kZXJlclBvcnRhbFJlZiB9IGZyb20gXCIuLi9yZW5kZXJlci9jZWxsLXBvcnRhbC1yZWZcIjtcbmltcG9ydCB7IERlZmF1bHRDZWxsUmVuZGVyZXJDb21wb25lbnQgfSBmcm9tIFwiLi4vcmVuZGVyZXIvZGVmYXVsdC1jZWxsLXJlbmRlcmVyL2RlZmF1bHQtY2VsbC1yZW5kZXJlci5jb21wb25lbnRcIjtcbmltcG9ydCB7IENvbHVtblRleHRTZWFyY2hGb3JtYXR0ZXIgfSBmcm9tIFwiLi4vc2VhcmNoL2NvbHVtbi10ZXh0LXNlYXJjaC1mb3JtYXR0ZXJcIjtcbmltcG9ydCB7IEVuYWJsZUNlbGxUZXh0U2VhcmNoIH0gZnJvbSBcIi4uL3NlYXJjaC9lbmFibGUtY2VsbC10ZXh0LXNlYXJjaC5kZWNvcmF0b3JcIjtcbmltcG9ydCB7IENlbGxSZW5kZXJlck9wdGlvbnMsIENvbHVtbk1vZGVsLCBPbkNvbXBvbmVudEluaXQgfSBmcm9tIFwiLi9jb2x1bW4tbW9kZWxcIjtcblxuZXhwb3J0IGNsYXNzIEN1c3RvbVZhbHVlQ29sdW1uTW9kZWw8Um93LCBWPiBleHRlbmRzIENvbHVtbk1vZGVsPFJvdz4ge1xuXG4gIGNvbnN0cnVjdG9yKGNvbHVtbklkOiBzdHJpbmcsIGRlZmF1bHRzOiBDb2x1bW5Nb2RlbC5UZXh0UHJvcGVydGllc1Byb3ZpZGVyLCBwcml2YXRlIGdldFZhbHVlOiAocm93OiBSb3cpID0+IFYpIHtcbiAgICBzdXBlcihjb2x1bW5JZCwgZGVmYXVsdHMpO1xuICAgIHRoaXMuY2VsbFJlbmRlcmVyKERlZmF1bHRDZWxsUmVuZGVyZXJDb21wb25lbnQpO1xuICB9XG5cbiAgY2VsbFJlbmRlcmVyPEMgZXh0ZW5kcyB7IHZhbHVlOiBQYXJ0aWFsPFY+IH0+KGNvbXBvbmVudFR5cGU6IENvbXBvbmVudFR5cGU8Qz4sIG9uQ29tcG9uZW50SW5pdE9yT3B0aW9ucz86IENlbGxSZW5kZXJlck9wdGlvbnM8Um93LCBDPiB8IE9uQ29tcG9uZW50SW5pdDxDPik6IHRoaXMge1xuICAgIHRoaXMuY29uZmlndXJlQ29sdW1uVGV4dFNlYXJjaChcbiAgICAgIEVuYWJsZUNlbGxUZXh0U2VhcmNoLmdldEZvcm1hdHRlcihjb21wb25lbnRUeXBlLCAoKSA9PiBuZXcgQ29sdW1uVGV4dFNlYXJjaEZvcm1hdHRlci5OdWxsKCkpLFxuICAgICAgcm93ID0+IHRoaXMuZ2V0VmFsdWUocm93KVxuICAgICk7XG4gICAgdGhpcy5jb25maWd1cmVDZWxsUmVuZGVyZXIobmV3IENvbXBvbmVudENlbGxSZW5kZXJlclBvcnRhbFJlZihjb21wb25lbnRUeXBlLCAoY29tcG9uZW50LCByb3dEYXRhLCBmaXJzdFRpbWUpID0+IHtcbiAgICAgIGlmIChmaXJzdFRpbWUpIHtcbiAgICAgICAgaWYgKGlzRnVuY3Rpb24ob25Db21wb25lbnRJbml0T3JPcHRpb25zKSkge1xuICAgICAgICAgIG9uQ29tcG9uZW50SW5pdE9yT3B0aW9ucyhjb21wb25lbnQpO1xuICAgICAgICB9IGVsc2Uge1xuICAgICAgICAgIGlmIChpc0Z1bmN0aW9uKG9uQ29tcG9uZW50SW5pdE9yT3B0aW9ucz8ub25Db21wb25lbnRJbml0KSkge1xuICAgICAgICAgICAgb25Db21wb25lbnRJbml0T3JPcHRpb25zLm9uQ29tcG9uZW50SW5pdChjb21wb25lbnQpO1xuICAgICAgICAgIH1cbiAgICAgICAgfVxuICAgICAgfVxuICAgICAgY29tcG9uZW50LnZhbHVlID0gdGhpcy5nZXRWYWx1ZShyb3dEYXRhLnJvdyk7XG5cbiAgICAgIGlmICghaXNGdW5jdGlvbihvbkNvbXBvbmVudEluaXRPck9wdGlvbnMpICYmIGlzRnVuY3Rpb24ob25Db21wb25lbnRJbml0T3JPcHRpb25zPy5vblJvd1VwZGF0ZSkpIHtcbiAgICAgICAgb25Db21wb25lbnRJbml0T3JPcHRpb25zLm9uUm93VXBkYXRlKGNvbXBvbmVudCwgcm93RGF0YS5yb3cpO1xuICAgICAgfVxuICAgIH0pKTtcbiAgICByZXR1cm4gdGhpcztcbiAgfVxuXG4gIHB1YmxpYyBzZWxlY3RSb3dPbkNsaWNrKHNlbGVjdE9uUm93Q2xpY2s6IGJvb2xlYW4pOiB0aGlzIHtcbiAgICByZXR1cm4gdGhpcy5fc2VsZWN0Um93T25DbGljayhzZWxlY3RPblJvd0NsaWNrKTtcbiAgfVxuXG59XG4iXX0=

package/esm2020/lib/components/tables/column/editor-controls-column-model.mjs

@@ -0,0 +1,21 @@
+import { EditRowControls } from "../editor/edit-row-controls/edit-row-controls.component";
+import { ComponentCellRendererPortalRef } from "../renderer/cell-portal-ref";
+import { ColumnModel } from "./column-model";
+export class EditorControlColumnModel extends ColumnModel {
+    constructor(columnId, saveCommandFactory, defaults) {
+        super(columnId, defaults);
+        this.cellRenderer(EditRowControls);
+    }
+    cellRenderer(componentType) {
+        this.configureCellRenderer(new ComponentCellRendererPortalRef(componentType, (component, rowData) => {
+            component.row = rowData.row;
+            component.editSession = rowData.editSession;
+            component.editRowCommand = rowData.editRowCommand;
+        }));
+        return this;
+    }
+    getDefaultHeaderText() {
+        return '';
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/components/tables/column/list-propery-column-model.mjs

@@ -0,0 +1,48 @@
+import { assert } from "@coolon/typescript-utilities";
+import { isFunction } from "lodash";
+import { CellEditorPortalRef, ComponentCellRendererPortalRef } from "../renderer/cell-portal-ref";
+import { DefaultListCellRendererComponent } from "../renderer/default-list-cell-renderer/default-list-cell-renderer.component";
+import { ColumnTextSearchFormatter } from "../search/column-text-search-formatter";
+import { EnableCellTextSearch } from "../search/enable-cell-text-search.decorator";
+import { ColumnModel } from "./column-model";
+export class ListPropertyColumnModel extends ColumnModel {
+    constructor(id, property, defaults) {
+        super(id, defaults);
+        this.property = property;
+        this._format = (value) => value.map(v => v?.toString()).join(", ");
+        this.cellRenderer(DefaultListCellRendererComponent);
+    }
+    cellRenderer(componentType) {
+        this.configureColumnTextSearch(EnableCellTextSearch.getFormatter(componentType, () => new ColumnTextSearchFormatter.DefaultArrayFormatter()), row => row[this.property]);
+        this.configureCellRenderer(new ComponentCellRendererPortalRef(componentType, (component, rowData) => {
+            let rowElement = rowData.row[this.property];
+            // @ts-ignore Started complaining in ts 4.5.. but I think my logic is correct...
+            component.value = this._format(rowElement);
+        }));
+        return this;
+    }
+    cellEditor(editor, validatorsOrInitialiser, initialiseComponent) {
+        const validators = Array.isArray(validatorsOrInitialiser) ? validatorsOrInitialiser : undefined;
+        const initialiser = isFunction(validatorsOrInitialiser) ? validatorsOrInitialiser : initialiseComponent;
+        this.configureCellEditor(new CellEditorPortalRef(editor, (component, editSession) => {
+            const formListModel = editSession.form.pluckList(this.property);
+            if (validators) {
+                formListModel.validateUsing(validators);
+            }
+            component.listModel = formListModel;
+            if (initialiser) {
+                initialiser(component);
+            }
+        }));
+        return this;
+    }
+    format(formatter) {
+        assert.isFunction(formatter);
+        this._format = formatter;
+        return this;
+    }
+    selectRowOnClick(selectRowOnClick) {
+        return this._selectRowOnClick(selectRowOnClick);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/components/tables/column/property-column-model.mjs

@@ -0,0 +1,92 @@
+import { assert } from "@coolon/typescript-utilities";
+import { isFunction } from "lodash";
+import { CellEditorPortalRef, ComponentCellRendererPortalRef } from "../renderer/cell-portal-ref";
+import { DefaultCellRendererComponent } from "../renderer/default-cell-renderer/default-cell-renderer.component";
+import { ColumnTextSearchFormatter } from "../search/column-text-search-formatter";
+import { EnableCellTextSearch } from "../search/enable-cell-text-search.decorator";
+import { ColumnModel } from "./column-model";
+export class PropertyColumnModel extends ColumnModel {
+    constructor(id, property, defaults) {
+        super(id, defaults);
+        this.property = property;
+        this._format = (value) => value?.toString();
+        this.cellRenderer(DefaultCellRendererComponent);
+    }
+    cellRenderer(componentType, onComponentInitOrOptions) {
+        this.configureColumnTextSearch(EnableCellTextSearch.getFormatter(componentType, () => new ColumnTextSearchFormatter.DefaultValueFormatter()), row => row[this.property]);
+        this.configureCellRenderer(new ComponentCellRendererPortalRef(componentType, (component, rowData, firstTime) => {
+            if (firstTime) {
+                if (isFunction(onComponentInitOrOptions)) {
+                    onComponentInitOrOptions(component);
+                }
+                else {
+                    if (isFunction(onComponentInitOrOptions?.onComponentInit)) {
+                        onComponentInitOrOptions.onComponentInit(component);
+                    }
+                }
+            }
+            component.value = this._format(rowData.row[this.property]);
+        }));
+        return this;
+    }
+    liveEditCellRenderer(componentType, options) {
+        return this.mutableCellRenderer(componentType, options);
+    }
+    /**
+     * Deprecated.  Use #liveEditCellRenderer instead.
+     * @param componentType
+     * @param options
+     */
+    mutableCellRenderer(componentType, options) {
+        this.configureCellRenderer(new ComponentCellRendererPortalRef(componentType, (component, rowData, firstTime) => {
+            // keep a local copy most recent row value so it's available to teh
+            // edit callback without having to add/remove subscribers all the time.
+            component[ColumnModel.CELL_RENDERER_COMPONENT_ROW_CACHE] = rowData.row;
+            let disableEditCallback = false;
+            if (firstTime) {
+                if (isFunction(options?.onComponentInit)) {
+                    options.onComponentInit(component);
+                }
+                // install our edit callback
+                component.onValueEdited((is, was) => {
+                    if (!disableEditCallback) {
+                        options.onValueEdit(component[ColumnModel.CELL_RENDERER_COMPONENT_ROW_CACHE], is, was);
+                    }
+                });
+            }
+            // now push the value the component and disable the callback just incase the component misbehaves
+            // and fires a value change during the operation.
+            disableEditCallback = true;
+            component.value = rowData.row[this.property];
+            disableEditCallback = false;
+            if (!isFunction(options) && isFunction(options?.onRowUpdate)) {
+                options.onRowUpdate(component, rowData.row);
+            }
+        }));
+        return this;
+    }
+    cellEditor(editor, validatorsOrInitialiser, onComponentInit) {
+        const validators = Array.isArray(validatorsOrInitialiser) ? validatorsOrInitialiser : undefined;
+        const initialiser = isFunction(validatorsOrInitialiser) ? validatorsOrInitialiser : onComponentInit;
+        this.configureCellEditor(new CellEditorPortalRef(editor, (component, editSession) => {
+            const formValueModel = editSession.form.pluck(this.property);
+            if (validators) {
+                formValueModel.validateUsing(validators);
+            }
+            component.valueModel = formValueModel;
+            if (initialiser) {
+                initialiser(component);
+            }
+        }));
+        return this;
+    }
+    format(formatter) {
+        assert.isFunction(formatter);
+        this._format = formatter;
+        return this;
+    }
+    selectRowOnClick(selectOnRowClick) {
+        return this._selectRowOnClick(selectOnRowClick);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"property-column-model.js","sourceRoot":"","sources":["../../../../../../../../libs/angular-ui-powerups/src/lib/components/tables/column/property-column-model.ts"],"names":[],"mappings":"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","sourcesContent":["import { ComponentType } from \"@angular/cdk/overlay\";\nimport { Types, Validator } from \"@coolon/pectin\";\nimport { assert } from \"@coolon/typescript-utilities\";\nimport { isFunction } from \"lodash\";\nimport { EditSession } from \"../editor/edit-session\";\nimport { EditableCellRenderer } from \"../editor/editable-cell-renderer\";\nimport { CellEditorComponent } from \"../renderer/cell-editors\";\nimport { CellEditorPortalRef, ComponentCellRendererPortalRef } from \"../renderer/cell-portal-ref\";\nimport { CellRenderer } from \"../renderer/cell-renderer\";\nimport { DefaultCellRendererComponent } from \"../renderer/default-cell-renderer/default-cell-renderer.component\";\nimport { ColumnTextSearchFormatter } from \"../search/column-text-search-formatter\";\nimport { EnableCellTextSearch } from \"../search/enable-cell-text-search.decorator\";\nimport { CellRendererOptions, ColumnModel, MutableCellRendererOptions, OnComponentInit } from \"./column-model\";\n\nexport class PropertyColumnModel<Row, P extends Types.ValuePropertiesOf<Row>> extends ColumnModel<Row> {\n\n  private _format: (value: Row[P]) => any = (value) => value?.toString();\n\n  constructor(id: string, readonly property: P, defaults: ColumnModel.TextPropertiesProvider) {\n    super(id, defaults);\n    this.cellRenderer(DefaultCellRendererComponent);\n  }\n\n  cellRenderer<E extends CellRenderer<Row[P]>>(componentType: ComponentType<E>, options?: CellRendererOptions<Row, E>): this\n  cellRenderer<E extends CellRenderer<Row[P]>>(componentType: ComponentType<E>, onComponentInit?: OnComponentInit<E>): this\n  cellRenderer<E extends CellRenderer<Row[P]>>(componentType: ComponentType<E>, onComponentInitOrOptions?: CellRendererOptions<Row, E> | OnComponentInit<E>): this {\n    this.configureColumnTextSearch(\n      EnableCellTextSearch.getFormatter(componentType, () => new ColumnTextSearchFormatter.DefaultValueFormatter()),\n      row => row[this.property]\n    );\n    this.configureCellRenderer(new ComponentCellRendererPortalRef(componentType, (component, rowData, firstTime) => {\n      if (firstTime) {\n        if (isFunction(onComponentInitOrOptions)) {\n          onComponentInitOrOptions(component);\n        } else {\n          if (isFunction(onComponentInitOrOptions?.onComponentInit)) {\n            onComponentInitOrOptions.onComponentInit(component);\n          }\n        }\n      }\n      component.value = this._format(rowData.row[this.property]);\n    }));\n    return this;\n  }\n\n  liveEditCellRenderer<E extends EditableCellRenderer<Row[P]>>(componentType: ComponentType<E>, options: MutableCellRendererOptions<Row, E, P>): this {\n    return this.mutableCellRenderer(componentType, options);\n  }\n\n  /**\n   * Deprecated.  Use #liveEditCellRenderer instead.\n   * @param componentType\n   * @param options\n   */\n  mutableCellRenderer<E extends EditableCellRenderer<Row[P]>>(componentType: ComponentType<E>, options: MutableCellRendererOptions<Row, E, P>): this {\n\n    this.configureCellRenderer(new ComponentCellRendererPortalRef(componentType, (component, rowData, firstTime) => {\n\n      // keep a local copy most recent row value so it's available to teh\n      // edit callback without having to add/remove subscribers all the time.\n      component[ColumnModel.CELL_RENDERER_COMPONENT_ROW_CACHE] = rowData.row;\n      let disableEditCallback = false;\n\n      if (firstTime) {\n        if (isFunction(options?.onComponentInit)) {\n          options.onComponentInit(component);\n        }\n        // install our edit callback\n        component.onValueEdited((is, was) => {\n          if (!disableEditCallback) {\n            options.onValueEdit(component[ColumnModel.CELL_RENDERER_COMPONENT_ROW_CACHE], is, was);\n          }\n        });\n\n      }\n\n      // now push the value the component and disable the callback just incase the component misbehaves\n      // and fires a value change during the operation.\n      disableEditCallback = true;\n      component.value = rowData.row[this.property];\n      disableEditCallback = false;\n\n      if (!isFunction(options) && isFunction(options?.onRowUpdate)) {\n        options.onRowUpdate(component, rowData.row);\n      }\n\n    }));\n    return this;\n  }\n\n  cellEditor<E extends CellEditorComponent<Row[P]>>(editor: ComponentType<E>, validators?: Validator<Row[P]>[], initialiseComponent?: (component: E) => void): this\n  cellEditor<E extends CellEditorComponent<Row[P]>>(editor: ComponentType<E>, initialiseComponent?: (component: E) => void): this\n  cellEditor<E extends CellEditorComponent<Row[P]>>(editor: ComponentType<E>, validatorsOrInitialiser?: Validator<Row[P]>[] | ((component: E) => void), onComponentInit?: (component: E) => void): this {\n    const validators = Array.isArray(validatorsOrInitialiser) ? validatorsOrInitialiser : undefined;\n    const initialiser = isFunction(validatorsOrInitialiser) ? validatorsOrInitialiser : onComponentInit;\n    this.configureCellEditor(new CellEditorPortalRef(editor, (component: E, editSession: EditSession<Row>) => {\n      const formValueModel = editSession.form.pluck(this.property);\n      if (validators) {\n        formValueModel.validateUsing(validators);\n      }\n      component.valueModel = formValueModel;\n      if (initialiser) {\n        initialiser(component);\n      }\n    }));\n    return this;\n  }\n\n  format(formatter: (value: Row[P]) => any): this {\n    assert.isFunction(formatter);\n    this._format = formatter;\n    return this;\n  }\n\n  public selectRowOnClick(selectOnRowClick: boolean): this {\n    return this._selectRowOnClick(selectOnRowClick);\n  }\n\n}\n"]}

package/esm2020/lib/components/tables/column/selection-column-model.mjs

@@ -0,0 +1,40 @@
+import { DelegatingSelectionModel, MultipleSelectionModel, ValueModel } from "@coolon/pectin";
+import { ComponentCellRendererPortalRef } from "../renderer/cell-portal-ref";
+import { SelectionHeaderCellComponent } from "../renderer/select-header-cell/selection-header-cell.component";
+import { SelectionCellComponent } from "../renderer/selection-cell/selection-cell.component";
+import { ColumnModel } from "./column-model";
+export class SelectionColumnModel extends ColumnModel {
+    constructor(columnId, defaults, selectionModel) {
+        super(columnId, defaults);
+        this._enableHeaderControls = true;
+        this.selectionModel = DelegatingSelectionModel.createDelegate();
+        this._selectRowOnClick(false);
+        this.cellHeaderRenderer(SelectionHeaderCellComponent, (component) => {
+            component.selectionModel = this.selectionModel;
+            component.enableHeaderControls = this._enableHeaderControls;
+        });
+        this.configureCellRenderer(new ComponentCellRendererPortalRef(SelectionCellComponent, (component, rowData) => {
+            component.row = rowData.row;
+            component.selectionModel = this.selectionModel;
+        }));
+        this.setSelectionModel(selectionModel);
+    }
+    setSelectionModel(selectionModel) {
+        this.selectionModel.setDelegate(selectionModel);
+        this.setDefaultVisibility(selectionModel instanceof MultipleSelectionModel ? ValueModel.TRUE : ValueModel.FALSE);
+    }
+    getDefaultHeaderText() {
+        return '';
+    }
+    enableHeaderControls(enable) {
+        this._enableHeaderControls = enable;
+        return this;
+    }
+    selectRow(row) {
+        this.selectionModel.selectCommand.execute(row);
+    }
+    isSelected(row) {
+        return this.selectionModel.isSelected(row);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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