@firestitch/list 13.0.2 → 13.0.3

package/esm2015/app/classes/reorder-controller.js

@@ -0,0 +1,183 @@
+import { Injectable } from '@angular/core';
+import { BehaviorSubject, Observable, Subject } from 'rxjs';
+import { takeUntil } from 'rxjs/operators';
+import * as i0 from "@angular/core";
+export var ReorderPosition;
+(function (ReorderPosition) {
+    ReorderPosition["Left"] = "left";
+    ReorderPosition["Right"] = "right";
+})(ReorderPosition || (ReorderPosition = {}));
+export var ReorderStrategy;
+(function (ReorderStrategy) {
+    ReorderStrategy["Always"] = "always";
+    ReorderStrategy["Manual"] = "manual";
+    ReorderStrategy["Custom"] = "custom";
+})(ReorderStrategy || (ReorderStrategy = {}));
+export class ReorderController {
+    constructor() {
+        this._enabled$ = new BehaviorSubject(false);
+        this._manualReorderActivated$ = new BehaviorSubject(false);
+        this._reorderDisabled$ = new BehaviorSubject(false);
+        this._position = new BehaviorSubject(null);
+        this._strategy = new BehaviorSubject(null);
+        this._destroy$ = new Subject();
+    }
+    get enabled() {
+        return this._enabled$.getValue();
+    }
+    set enabled(value) {
+        this._enabled$.next(value);
+        this._manualReorderActivated$.next(this.enabled && this.strategy === ReorderStrategy.Manual);
+    }
+    get strategy() {
+        return this._strategy.getValue();
+    }
+    get position() {
+        return this._position.getValue();
+    }
+    get dataController() {
+        return this._dataController;
+    }
+    get selectionController() {
+        return this._selectionController;
+    }
+    get enabled$() {
+        return this._enabled$.asObservable();
+    }
+    get position$() {
+        return this._position.asObservable();
+    }
+    get strategy$() {
+        return this._strategy.asObservable();
+    }
+    get manualReorderActivated() {
+        return this._manualReorderActivated$.getValue();
+    }
+    get reorderDisabled$() {
+        return this._reorderDisabled$.asObservable();
+    }
+    get reorderDisabled() {
+        return this._reorderDisabled$.getValue();
+    }
+    initWithConfig(data, dataController, actionsController, selectionController) {
+        var _a, _b, _c;
+        if (!data) {
+            return;
+        }
+        this.menu = (_a = data.menu) !== null && _a !== void 0 ? _a : false;
+        this._setPosition((_b = data.position) !== null && _b !== void 0 ? _b : ReorderPosition.Left);
+        if (!data.disabled) {
+            this._setStrategy(ReorderStrategy.Always);
+        }
+        if (data.toggle) {
+            this._setStrategy(ReorderStrategy.Manual);
+        }
+        // this.strategy = data.strategy ?? ReorderStrategy.Manual;
+        this.label = data.label;
+        this.multiple = data.multiple;
+        this.status = (_c = data.status) !== null && _c !== void 0 ? _c : true;
+        this.startCallback = data.start;
+        this.movedCallback = data.moved;
+        this.doneCallback = data.done;
+        this.moveDropCallback = data.moveDrop;
+        this._dataController = dataController;
+        this._actionsController = actionsController;
+        this._selectionController = selectionController;
+        if (this.strategy === ReorderStrategy.Always) {
+            this.enableReorder();
+        }
+        else if (this.strategy === ReorderStrategy.Manual) {
+            actionsController.addReorderAction({
+                label: this.label || 'Reorder',
+                menu: this.menu,
+                primary: false,
+                click: () => {
+                    this.enableReorder();
+                },
+                disabled: () => {
+                    return this.reorderDisabled;
+                }
+            });
+            actionsController.addReorderDoneAction({
+                label: 'Done',
+                primary: false,
+                click: () => {
+                    this.disableReorder();
+                },
+                disabled: () => {
+                    return this.reorderDisabled;
+                },
+            });
+        }
+    }
+    enableReorder() {
+        if ((this.strategy === ReorderStrategy.Manual || this.strategy === ReorderStrategy.Custom) && this.startCallback) {
+            const returnedValue = this.startCallback();
+            if (returnedValue && returnedValue instanceof Observable) {
+                this.disableReorderAction();
+                returnedValue
+                    .pipe(takeUntil(this._destroy$))
+                    .subscribe(() => {
+                    this.enabled = true;
+                    this.enableReorderAction();
+                });
+                return;
+            }
+        }
+        this.enabled = true;
+    }
+    disableReorder() {
+        if (this.strategy === ReorderStrategy.Manual || this.strategy === ReorderStrategy.Custom) {
+            const returnedValue = this.reorderFinished();
+            if (returnedValue && returnedValue instanceof Observable) {
+                this.disableReorderAction();
+                returnedValue
+                    .pipe(takeUntil(this._destroy$))
+                    .subscribe(() => {
+                    this.enabled = false;
+                    this.enableReorderAction();
+                });
+                return;
+            }
+        }
+        this.enabled = false;
+    }
+    /**
+     * Exec end callback
+     */
+    reorderFinished() {
+        if (this.doneCallback) {
+            return this.doneCallback(this._dataController.reorderData);
+        }
+    }
+    ngOnDestroy() {
+        this._destroy$.next();
+        this._destroy$.complete();
+    }
+    /**
+     * Enable reorder action and update filter actions state
+     */
+    enableReorderAction() {
+        this._reorderDisabled$.next(false);
+        this._actionsController.updateDisabledState();
+    }
+    /**
+     * Disable reorder action and update filter actions state
+     */
+    disableReorderAction() {
+        this._reorderDisabled$.next(true);
+        this._actionsController.updateDisabledState();
+    }
+    _setPosition(value) {
+        this._position.next(value);
+    }
+    _setStrategy(value) {
+        this._strategy.next(value);
+    }
+}
+ReorderController.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: ReorderController, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+ReorderController.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: ReorderController });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: ReorderController, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return []; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"reorder-controller.js","sourceRoot":"","sources":["../../../../src/app/classes/reorder-controller.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable, OnDestroy } from '@angular/core';\n\nimport { BehaviorSubject, Observable, Subject } from 'rxjs';\nimport { takeUntil } from 'rxjs/operators';\n\nimport {\n  FsListReorderConfig,\n  FsListReorderDoneCallback,\n  FsListReorderMovedCallback,\n  FsListReorderMoveInGroupCallback\n} from '../interfaces';\n\nimport { DataController } from './data-controller';\nimport { ActionsController } from './actions-controller';\nimport { SelectionController } from './selection-controller';\n\nexport enum ReorderPosition {\n  Left = 'left',\n  Right = 'right',\n}\n\nexport enum ReorderStrategy {\n  Always = 'always',\n  Manual = 'manual',\n  Custom = 'custom',\n}\n\n@Injectable()\nexport class ReorderController implements OnDestroy {\n\n  public startCallback: () => void | Observable<void>;\n  public movedCallback: FsListReorderMovedCallback;\n  public doneCallback: FsListReorderDoneCallback;\n  public moveDropCallback: FsListReorderMoveInGroupCallback;\n\n  public status: boolean;\n  public label: string;\n  public menu: boolean;\n  public multiple: boolean;\n\n  private _dataController: DataController;\n  private _actionsController: ActionsController;\n  private _selectionController: SelectionController;\n\n  private _enabled$ = new BehaviorSubject<boolean>(false);\n  private _manualReorderActivated$ = new BehaviorSubject(false);\n  private _reorderDisabled$ = new BehaviorSubject(false);\n  private _position = new BehaviorSubject<ReorderPosition | null>(null);\n  private _strategy = new BehaviorSubject<ReorderStrategy | null>(null);\n\n  private _destroy$ = new Subject();\n\n  constructor() {}\n\n  public get enabled() {\n    return this._enabled$.getValue();\n  }\n\n  public set enabled(value) {\n    this._enabled$.next(value);\n\n    this._manualReorderActivated$.next(this.enabled && this.strategy === ReorderStrategy.Manual);\n  }\n\n  public get strategy(): ReorderStrategy | null {\n    return this._strategy.getValue();\n  }\n\n  public get position(): ReorderPosition | null {\n    return this._position.getValue();\n  }\n\n  public get dataController() {\n    return this._dataController;\n  }\n\n  public get selectionController(): SelectionController {\n    return this._selectionController;\n  }\n\n  public get enabled$(): Observable<boolean> {\n    return this._enabled$.asObservable();\n  }\n\n  public get position$(): Observable<ReorderPosition> {\n    return this._position.asObservable();\n  }\n\n  public get strategy$(): Observable<ReorderStrategy> {\n    return this._strategy.asObservable();\n  }\n\n  public get manualReorderActivated(): boolean {\n    return this._manualReorderActivated$.getValue();\n  }\n\n  public get reorderDisabled$(): Observable<boolean> {\n    return this._reorderDisabled$.asObservable();\n  }\n\n  public get reorderDisabled(): boolean {\n    return this._reorderDisabled$.getValue();\n  }\n\n  public initWithConfig(\n    data: FsListReorderConfig,\n    dataController: DataController,\n    actionsController: ActionsController,\n    selectionController: SelectionController,\n  ) {\n    if (!data) { return }\n\n    this.menu = data.menu ?? false;\n    this._setPosition(data.position ?? ReorderPosition.Left);\n\n    if (!data.disabled) {\n      this._setStrategy(ReorderStrategy.Always);\n    }\n\n    if (data.toggle) {\n      this._setStrategy(ReorderStrategy.Manual);\n    }\n    // this.strategy = data.strategy ?? ReorderStrategy.Manual;\n    this.label = data.label;\n    this.multiple = data.multiple;\n    this.status = data.status ?? true;\n\n    this.startCallback = data.start;\n    this.movedCallback = data.moved;\n    this.doneCallback = data.done;\n    this.moveDropCallback = data.moveDrop;\n\n    this._dataController = dataController;\n    this._actionsController = actionsController;\n    this._selectionController = selectionController;\n\n    if (this.strategy === ReorderStrategy.Always) {\n      this.enableReorder();\n    } else if (this.strategy === ReorderStrategy.Manual) {\n      actionsController.addReorderAction(\n        {\n          label: this.label || 'Reorder',\n          menu: this.menu,\n          primary: false,\n          click: () => {\n            this.enableReorder();\n          },\n          disabled: () => {\n            return this.reorderDisabled;\n          }\n        }\n      );\n\n      actionsController.addReorderDoneAction({\n          label: 'Done',\n          primary: false,\n          click: () => {\n            this.disableReorder();\n          },\n          disabled: () => {\n            return this.reorderDisabled;\n          },\n        }\n      )\n    }\n  }\n\n  public enableReorder() {\n    if ((this.strategy === ReorderStrategy.Manual || this.strategy === ReorderStrategy.Custom) && this.startCallback) {\n      const returnedValue = this.startCallback();\n\n      if (returnedValue && returnedValue instanceof Observable) {\n        this.disableReorderAction();\n\n        returnedValue\n          .pipe(\n            takeUntil(this._destroy$),\n          )\n          .subscribe(() => {\n            this.enabled = true;\n            this.enableReorderAction();\n          });\n\n        return;\n      }\n    }\n\n    this.enabled = true;\n  }\n\n  public disableReorder() {\n    if (this.strategy === ReorderStrategy.Manual || this.strategy === ReorderStrategy.Custom) {\n      const returnedValue = this.reorderFinished();\n\n      if (returnedValue && returnedValue instanceof Observable) {\n        this.disableReorderAction();\n\n        returnedValue\n          .pipe(\n            takeUntil(this._destroy$),\n          )\n          .subscribe(() => {\n            this.enabled = false;\n            this.enableReorderAction();\n          });\n\n        return;\n      }\n    }\n\n    this.enabled = false;\n  }\n\n  /**\n   * Exec end callback\n   */\n  public reorderFinished() {\n    if (this.doneCallback) {\n      return this.doneCallback(this._dataController.reorderData);\n    }\n  }\n\n  public ngOnDestroy() {\n    this._destroy$.next();\n    this._destroy$.complete();\n  }\n\n  /**\n   * Enable reorder action and update filter actions state\n   */\n  public enableReorderAction() {\n    this._reorderDisabled$.next(false);\n    this._actionsController.updateDisabledState();\n  }\n\n  /**\n   * Disable reorder action and update filter actions state\n   */\n  public disableReorderAction() {\n    this._reorderDisabled$.next(true);\n    this._actionsController.updateDisabledState();\n  }\n\n  private _setPosition(value: ReorderPosition): void {\n    this._position.next(value);\n  }\n\n  private _setStrategy(value: ReorderStrategy): void {\n    this._strategy.next(value);\n  }\n\n}\n"]}