ember-headless-table 1.1.0 → 1.2.0

package/dist/plugins/column-reordering/plugin.js

@@ -1,7 +1,7 @@
-import { _ as _initializerDefineProperty } from '../../table-8e46554b.js';
-import { _ as _applyDecoratedDescriptor } from '../../applyDecoratedDescriptor-e0489e2f.js';
-import { a as _classPrivateFieldGet } from '../../classPrivateFieldGet-af59a8ea.js';
-import { _ as _defineProperty } from '../../defineProperty-a0196711.js';
+import { _ as _initializerDefineProperty } from '../../table-222f44e7.js';
+import { _ as _applyDecoratedDescriptor } from '../../applyDecoratedDescriptor-6b986a67.js';
+import { a as _classPrivateFieldGet } from '../../classPrivateFieldGet-b4d7d334.js';
+import { _ as _defineProperty } from '../../defineProperty-35ce617b.js';
 import { macroCondition, dependencySatisfies, importSync } from '@embroider/macros';
 import { tracked } from '@glimmer/tracking';
 import { assert } from '@ember/debug';
@@ -10,92 +10,77 @@ import { TrackedMap } from 'tracked-built-ins';
 import { BasePlugin, meta, preferences, columns } from '../-private/base.js';
 
 var _class, _descriptor, _class3;
-
 function _classPrivateFieldInitSpec(obj, privateMap, value) { _checkPrivateRedeclaration(obj, privateMap); privateMap.set(obj, value); }
-
 function _checkPrivateRedeclaration(obj, privateCollection) { if (privateCollection.has(obj)) { throw new TypeError("Cannot initialize the same private elements twice on an object"); } }
 let cached = macroCondition(dependencySatisfies('ember-source', '>= 4.1.0-alpha.0')) ? importSync('@glimmer/tracking').cached : importSync('ember-cached-decorator-polyfill').cached;
 class ColumnReordering extends BasePlugin {
   constructor(...args) {
     super(...args);
-
     _defineProperty(this, "name", 'column-reordering');
-
     _defineProperty(this, "meta", {
       column: ColumnMeta,
       table: TableMeta
     });
   }
-
   reset() {
     let tableMeta = meta.forTable(this.table, ColumnReordering);
     tableMeta.reset();
   }
-
   get columns() {
     return meta.forTable(this.table, ColumnReordering).columns;
   }
-
 }
-
 _defineProperty(ColumnReordering, "features", ['columnOrder']);
-
 var _tableMeta = /*#__PURE__*/new WeakMap();
-
 class ColumnMeta {
   constructor(column) {
     _classPrivateFieldInitSpec(this, _tableMeta, {
       get: _get_tableMeta,
       set: void 0
     });
-
-    _defineProperty(this, "moveLeft", () => this.position--);
-
-    _defineProperty(this, "moveRight", () => this.position++);
-
+    _defineProperty(this, "moveLeft", () => {
+      _classPrivateFieldGet(this, _tableMeta).columnOrder.moveLeft(this.column.key);
+    });
+    _defineProperty(this, "moveRight", () => {
+      _classPrivateFieldGet(this, _tableMeta).columnOrder.moveRight(this.column.key);
+    });
     this.column = column;
   }
-
   get position() {
     return _classPrivateFieldGet(this, _tableMeta).getPosition(this.column);
   }
-
   set position(value) {
     _classPrivateFieldGet(this, _tableMeta).setPosition(this.column, value);
   }
-
   get canMoveLeft() {
     return _classPrivateFieldGet(this, _tableMeta).getPosition(this.column) !== 0;
   }
-
   get canMoveRight() {
     return _classPrivateFieldGet(this, _tableMeta).getPosition(this.column) !== _classPrivateFieldGet(this, _tableMeta).columns.length - 1;
   }
-
   get cannotMoveLeft() {
     return !this.canMoveLeft;
   }
-
   get cannotMoveRight() {
     return !this.canMoveRight;
   }
+
   /**
    * Move the column one spot to the left
    */
-
-
 }
-
 function _get_tableMeta() {
   return meta.forTable(this.column.table, ColumnReordering);
 }
-
 let TableMeta = (_class = class TableMeta {
   constructor(table) {
     _initializerDefineProperty(this, "columnOrder", _descriptor, this);
-
+    _defineProperty(this, "setOrder", order => {
+      this.columnOrder.setAll(order.map);
+    });
     this.table = table;
   }
+
   /**
    * @private
    *
@@ -105,20 +90,28 @@ let TableMeta = (_class = class TableMeta {
    * This is also why the order of the columns is maintained via column key
    */
 
-
+  /**
+   * Get the curret order/position of a column
+   */
   getPosition(column) {
     return this.columnOrder.get(column.key);
   }
 
+  /**
+   * Swap the column with the column at `newPosition`
+   */
   setPosition(column, newPosition) {
-    return this.columnOrder.set(column.key, newPosition);
+    return this.columnOrder.swapWith(column.key, newPosition);
   }
+
+  /**
+   * Using a `ColumnOrder` instance, set the order of all columns
+   */
+
   /**
    * Revert to default config, delete preferences,
    * and clear the columnOrder
    */
-
-
   reset() {
     preferences.forTable(this.table, ColumnReordering).delete('order');
     this.columnOrder = new ColumnOrder({
@@ -126,44 +119,37 @@ let TableMeta = (_class = class TableMeta {
       save: this.save
     });
   }
+
   /**
    * @private
    */
-
-
   save(map) {
     let order = {};
-
     for (let [key, position] of map.entries()) {
       order[key] = position;
     }
-
     preferences.forTable(this.table, ColumnReordering).set('order', order);
   }
+
   /**
    * @private
    */
-
-
   read() {
     let order = preferences.forTable(this.table, ColumnReordering).get('order');
     if (!order) return;
     return new Map(Object.entries(order));
   }
-
   get columns() {
     return this.columnOrder.orderedColumns;
   }
+
   /**
    * @private
    * This isn't our data to expose, but it is useful to alias
    */
-
-
   get availableColumns() {
     return columns.for(this.table, ColumnReordering);
   }
-
 }, (_descriptor = _applyDecoratedDescriptor(_class.prototype, "columnOrder", [tracked], {
   configurable: true,
   enumerable: true,
@@ -176,143 +162,146 @@ let TableMeta = (_class = class TableMeta {
     });
   }
 }), _applyDecoratedDescriptor(_class.prototype, "getPosition", [action], Object.getOwnPropertyDescriptor(_class.prototype, "getPosition"), _class.prototype), _applyDecoratedDescriptor(_class.prototype, "setPosition", [action], Object.getOwnPropertyDescriptor(_class.prototype, "setPosition"), _class.prototype), _applyDecoratedDescriptor(_class.prototype, "reset", [action], Object.getOwnPropertyDescriptor(_class.prototype, "reset"), _class.prototype), _applyDecoratedDescriptor(_class.prototype, "save", [action], Object.getOwnPropertyDescriptor(_class.prototype, "save"), _class.prototype), _applyDecoratedDescriptor(_class.prototype, "read", [action], Object.getOwnPropertyDescriptor(_class.prototype, "read"), _class.prototype)), _class);
+
 /**
  * @private
  * Used for keeping track of and updating column order
  */
-
 let ColumnOrder = (_class3 = class ColumnOrder {
   /**
    * This map will be empty until we re-order something.
    */
+
   constructor(args) {
     _defineProperty(this, "map", new TrackedMap());
-
+    _defineProperty(this, "setAll", map => {
+      this.map.clear();
+      for (let [key, value] of map.entries()) {
+        this.map.set(key, value);
+      }
+    });
     this.args = args;
-
     if (args.existingOrder) {
       this.map = new TrackedMap(args.existingOrder);
     }
   }
 
-  set(key, position) {
-    /**
-     * Cannot set a position lower than the min value (before the beginning?)
-     */
-    if (position < 0) {
-      return false;
+  /**
+   * To account for columnVisibilty, we need to:
+   * - get the list of visible columns
+   * - get the column order (which preserves the order of hidden columns)
+   * - skip over non-visible columns when determining the previous "index"
+   * - set the position to whatever that is.
+   */
+  moveLeft(key) {
+    let orderedColumns = this.orderedColumns;
+    let found = false;
+    let nextColumn;
+    for (let column of orderedColumns.reverse()) {
+      if (found) {
+        nextColumn = column;
+        break;
+      }
+      if (column.key === key) {
+        found = true;
+      }
     }
-    /**
-     * position is 0-indexed and length includes 0 in its count of items
-     */
+    if (!nextColumn) return;
+    let nextPosition = this.get(nextColumn.key);
+    this.swapWith(key, nextPosition);
+  }
+  /**
+   * To account for columnVisibilty, we need to:
+   * - get the list of visible columns
+   * - get the column order (which preserves the order of hidden columns)
+   * - skip over non-visible columns when determining the next "index"
+   * - set the position to whatever that is.
+   */
+  moveRight(key) {
+    let orderedColumns = this.orderedColumns;
+    let found = false;
+    let nextColumn;
+    for (let column of orderedColumns) {
+      if (found) {
+        nextColumn = column;
+        break;
+      }
+      if (column.key === key) {
+        found = true;
+      }
+    }
+    if (!nextColumn) return;
+    let nextPosition = this.get(nextColumn.key);
+    this.swapWith(key, nextPosition);
+  }
 
+  /**
+   * Performs a swap of the column's position with the column at position
+   */
+  swapWith(key, position) {
+    let validPositions = [...this.orderedMap.values()];
 
-    let maxPosition = this.args.columns().length - 1;
     /**
-     * Cannot set a position higher than the max value (after the end?)
+     * Position to swap to must exist
      */
-
-    if (position > maxPosition) {
-      return false;
+    if (!validPositions.includes(position)) {
+      return;
     }
+
     /**
      * Where did this column `key` come from? we can find out
      * by reading orderedMap
      */
-
-
     let currentPosition = this.orderedMap.get(key);
     assert(`Pre-existing position for ${key} could not be found. Does the column exist? ` + `The current positions are: ` + [...this.orderedMap.entries()].map(entry => entry.join(' => ')).join(', ') + ` and the availableColumns are: ` + this.args.columns().map(column => column.key) + ` and current "map" (${this.map.size}) is: ` + [...this.map.entries()].map(entry => entry.join(' => ')).join(', '), undefined !== currentPosition);
+
     /**
      * No need to change anything if the position is the same
      * This helps reduce @tracked invalidations, which in turn reduces DOM thrashing.
      */
-
     if (currentPosition === position) {
       return false;
     }
-    /**
-     * For the columns between the gap we took `key` from and the `position`
-     * we want to place that column, which direction do we move those middle columns?
-     */
-
-
-    let direction = currentPosition < position ?
-    /**
-     *   moved ------------------> to the right
-     * currentPosition         position
-     *   gap ^
-     * columns left of position now need to shift left to fill that gap
-     */
-    'left' :
-    /**
-     *   moved <------------------ to the left
-     * position         currentPosition
-     *                    gap ^
-     * columns right of position now need to shift right to fill that gap
-     */
-    'right';
     let keyByPosition = new Map([...this.orderedMap.entries()].map(entry => entry.reverse()));
-
     for (let [existingPosition, key] of keyByPosition.entries()) {
-      if (direction === 'left') {
-        if (existingPosition > currentPosition && existingPosition <= position) {
-          this.map.set(key, existingPosition - 1);
-        }
-      }
-
-      if (direction === 'right') {
-        if (existingPosition >= position && existingPosition <= currentPosition) {
-          this.map.set(key, existingPosition + 1);
-        }
+      if (existingPosition === position) {
+        /**
+         * We swap positions because the positions are not incremental
+         * meaning we can have gaps, intentionally, due to hidden columns
+         */
+        this.map.set(key, currentPosition);
+        break;
       }
     }
+
     /**
      * Finally, set the position for the requested column
      */
-
-
     this.map.set(key, position);
+
     /**
      * Now that we've set the value for one column,
      * we need to make sure that all columns have a recorded position.
      */
-
     for (let [key, position] of this.orderedMap.entries()) {
       if (this.map.has(key)) continue;
       this.map.set(key, position);
     }
-
-    this.args.save(this.map);
+    this.args.save?.(this.map);
   }
-
   get(key) {
     let result = this.orderedMap.get(key);
-    assert(`No position found for ${key}. Is the column used within this table?`,
-    /* 0 is falsey, but it's a valid value for position */
+    assert(`No position found for ${key}. Is the column used within this table?`, /* 0 is falsey, but it's a valid value for position */
     undefined !== result);
     return result;
   }
+
   /**
    * The same as this.map, but with all the columns' information
    */
-
-
   get orderedMap() {
     return orderOf(this.args.columns(), this.map);
   }
-  /**
-   * When columns are removed or hidden, our positions don't change
-   * but when doing the math, we want to adjust things based on 0-indexed counting
-   *
-   * TODO: figure out if we need this??
-   */
-
-
-  get adjustedColumns() {
-    return [];
-  }
-
   get orderedColumns() {
     let availableColumns = this.args.columns();
     let availableByKey = availableColumns.reduce((keyMap, column) => {
@@ -323,37 +312,33 @@ let ColumnOrder = (_class3 = class ColumnOrder {
     let result = Array.from({
       length: availableColumns.length
     });
-
     for (let [key, position] of mergedOrder.entries()) {
       let column = availableByKey[key];
       assert(`Could not find column for pair: ${key} @ @{position}`, column);
       result[position] = column;
     }
-
     assert(`Generated orderedColumns' length (${result.filter(Boolean).length}) ` + `does not match the length of available columns (${availableColumns.length}). ` + `orderedColumns: ${result.filter(Boolean).map(c => c.key).join(', ')} -- ` + `available columns: ${availableColumns.map(c => c.key).join(', ')}`, result.filter(Boolean).length === availableColumns.length);
     return result.filter(Boolean);
   }
+}, (_applyDecoratedDescriptor(_class3.prototype, "moveLeft", [action], Object.getOwnPropertyDescriptor(_class3.prototype, "moveLeft"), _class3.prototype), _applyDecoratedDescriptor(_class3.prototype, "moveRight", [action], Object.getOwnPropertyDescriptor(_class3.prototype, "moveRight"), _class3.prototype), _applyDecoratedDescriptor(_class3.prototype, "swapWith", [action], Object.getOwnPropertyDescriptor(_class3.prototype, "swapWith"), _class3.prototype), _applyDecoratedDescriptor(_class3.prototype, "get", [action], Object.getOwnPropertyDescriptor(_class3.prototype, "get"), _class3.prototype), _applyDecoratedDescriptor(_class3.prototype, "orderedMap", [cached], Object.getOwnPropertyDescriptor(_class3.prototype, "orderedMap"), _class3.prototype), _applyDecoratedDescriptor(_class3.prototype, "orderedColumns", [cached], Object.getOwnPropertyDescriptor(_class3.prototype, "orderedColumns"), _class3.prototype)), _class3);
 
-}, (_applyDecoratedDescriptor(_class3.prototype, "set", [action], Object.getOwnPropertyDescriptor(_class3.prototype, "set"), _class3.prototype), _applyDecoratedDescriptor(_class3.prototype, "get", [action], Object.getOwnPropertyDescriptor(_class3.prototype, "get"), _class3.prototype), _applyDecoratedDescriptor(_class3.prototype, "orderedMap", [cached], Object.getOwnPropertyDescriptor(_class3.prototype, "orderedMap"), _class3.prototype), _applyDecoratedDescriptor(_class3.prototype, "adjustedColumns", [cached], Object.getOwnPropertyDescriptor(_class3.prototype, "adjustedColumns"), _class3.prototype), _applyDecoratedDescriptor(_class3.prototype, "orderedColumns", [cached], Object.getOwnPropertyDescriptor(_class3.prototype, "orderedColumns"), _class3.prototype)), _class3);
 /**
  * @private
  *
  * Utility for helping determine the percieved order of a set of columns
  * given the original (default) ordering, and then user-configurations
  */
-
 function orderOf(columns, currentOrder) {
   let result = new Map();
   let availableColumns = columns.map(column => column.key);
   let availableSet = new Set(availableColumns);
   let current = new Map([...currentOrder.entries()].map(([key, position]) => [position, key]));
+
   /**
    * O(n * log(n)) ?
    */
-
   for (let i = 0; i < Math.max(columns.length, current.size); i++) {
     let orderedKey = current.get(i);
-
     if (orderedKey) {
       /**
        * If the currentOrder specifies columns not presently available,
@@ -364,27 +349,21 @@ function orderOf(columns, currentOrder) {
         continue;
       }
     }
-
     let availableKey;
-
     while (availableKey = availableColumns.shift()) {
       if (result.has(availableKey) || currentOrder.has(availableKey)) {
         continue;
       }
-
       break;
     }
-
     if (!availableKey) {
       /**
        * The rest of our columns likely have their order set
        */
       continue;
     }
-
     result.set(availableKey, i);
   }
-
   return result;
 }
 

package/dist/plugins/column-reordering/plugin.js.map

@@ -1 +1 @@
-{"version":3,"file":"plugin.js","sources":["../../../src/plugins/column-reordering/plugin.ts"],"sourcesContent":["import { cached, tracked } from '@glimmer/tracking';\nimport { assert } from '@ember/debug';\nimport { action } from '@ember/object';\n\nimport { TrackedMap } from 'tracked-built-ins';\n\nimport { preferences } from '[public-plugin-types]';\n\nimport { BasePlugin, columns, meta } from '../-private/base';\n\nimport type { PluginPreferences } from '[public-plugin-types]';\nimport type { Column, Table } from '[public-types]';\n\ninterface ColumnReorderingPreferences extends PluginPreferences {\n  table: {\n    order?: Record<string, number>;\n  };\n}\n\ndeclare module 'ember-headless-table/plugins' {\n  interface Registry {\n    ColumnReordering?: ColumnReorderingPreferences;\n  }\n}\n\nexport interface Signature {\n  Meta: {\n    Column: ColumnMeta;\n    Table: TableMeta;\n  };\n}\n\nexport class ColumnReordering extends BasePlugin<Signature> {\n  name = 'column-reordering';\n  static features = ['columnOrder'];\n\n  meta = {\n    column: ColumnMeta,\n    table: TableMeta,\n  } as const;\n\n  reset() {\n    let tableMeta = meta.forTable(this.table, ColumnReordering);\n\n    tableMeta.reset();\n  }\n\n  get columns() {\n    return meta.forTable(this.table, ColumnReordering).columns;\n  }\n}\n\nexport class ColumnMeta {\n  constructor(private column: Column) {}\n\n  get #tableMeta() {\n    return meta.forTable(this.column.table, ColumnReordering);\n  }\n\n  get position() {\n    return this.#tableMeta.getPosition(this.column);\n  }\n\n  set position(value: number) {\n    this.#tableMeta.setPosition(this.column, value);\n  }\n\n  get canMoveLeft() {\n    return this.#tableMeta.getPosition(this.column) !== 0;\n  }\n\n  get canMoveRight() {\n    return this.#tableMeta.getPosition(this.column) !== this.#tableMeta.columns.length - 1;\n  }\n\n  get cannotMoveLeft() {\n    return !this.canMoveLeft;\n  }\n\n  get cannotMoveRight() {\n    return !this.canMoveRight;\n  }\n\n  /**\n   * Move the column one spot to the left\n   */\n  moveLeft = () => this.position--;\n\n  /**\n   * Move the column one spot to the right\n   */\n  moveRight = () => this.position++;\n}\n\nexport class TableMeta {\n  constructor(private table: Table) {}\n\n  /**\n   * @private\n   *\n   * We want to maintain the instance of this ColumnOrder class because\n   * we allow the consumer of the table to swap out columns at any time.\n   * When they do this, we want to maintain the order of the table, best we can.\n   * This is also why the order of the columns is maintained via column key\n   */\n  @tracked\n  columnOrder = new ColumnOrder({\n    columns: () => this.availableColumns,\n    save: this.save,\n    existingOrder: this.read(),\n  });\n\n  @action\n  getPosition(column: Column) {\n    return this.columnOrder.get(column.key);\n  }\n\n  @action\n  setPosition(column: Column, newPosition: number) {\n    return this.columnOrder.set(column.key, newPosition);\n  }\n\n  /**\n   * Revert to default config, delete preferences,\n   * and clear the columnOrder\n   */\n  @action\n  reset() {\n    preferences.forTable(this.table, ColumnReordering).delete('order');\n    this.columnOrder = new ColumnOrder({\n      columns: () => this.availableColumns,\n      save: this.save,\n    });\n  }\n\n  /**\n   * @private\n   */\n  @action\n  save(map: Map<string, number>) {\n    let order: Record<string, number> = {};\n\n    for (let [key, position] of map.entries()) {\n      order[key] = position;\n    }\n\n    preferences.forTable(this.table, ColumnReordering).set('order', order);\n  }\n\n  /**\n   * @private\n   */\n  @action\n  private read() {\n    let order = preferences.forTable(this.table, ColumnReordering).get('order');\n\n    if (!order) return;\n\n    return new Map<string, number>(Object.entries(order));\n  }\n\n  get columns() {\n    return this.columnOrder.orderedColumns;\n  }\n\n  /**\n   * @private\n   * This isn't our data to expose, but it is useful to alias\n   */\n  private get availableColumns() {\n    return columns.for(this.table, ColumnReordering);\n  }\n}\n\n/**\n * @private\n * Used for keeping track of and updating column order\n */\nexport class ColumnOrder {\n  /**\n   * This map will be empty until we re-order something.\n   */\n  map = new TrackedMap<string, number>();\n\n  constructor(\n    private args: {\n      columns: () => Column[];\n      save: (order: Map<string, number>) => void;\n      existingOrder?: Map<string, number>;\n    }\n  ) {\n    if (args.existingOrder) {\n      this.map = new TrackedMap(args.existingOrder);\n    }\n  }\n\n  @action\n  set(key: string, position: number) {\n    /**\n     * Cannot set a position lower than the min value (before the beginning?)\n     */\n    if (position < 0) {\n      return false;\n    }\n\n    /**\n     * position is 0-indexed and length includes 0 in its count of items\n     */\n    let maxPosition = this.args.columns().length - 1;\n\n    /**\n     * Cannot set a position higher than the max value (after the end?)\n     */\n    if (position > maxPosition) {\n      return false;\n    }\n\n    /**\n     * Where did this column `key` come from? we can find out\n     * by reading orderedMap\n     */\n    let currentPosition = this.orderedMap.get(key);\n\n    assert(\n      `Pre-existing position for ${key} could not be found. Does the column exist? ` +\n        `The current positions are: ` +\n        [...this.orderedMap.entries()].map((entry) => entry.join(' => ')).join(', ') +\n        ` and the availableColumns are: ` +\n        this.args.columns().map((column) => column.key) +\n        ` and current \"map\" (${this.map.size}) is: ` +\n        [...this.map.entries()].map((entry) => entry.join(' => ')).join(', '),\n      undefined !== currentPosition\n    );\n\n    /**\n     * No need to change anything if the position is the same\n     * This helps reduce @tracked invalidations, which in turn reduces DOM thrashing.\n     */\n    if (currentPosition === position) {\n      return false;\n    }\n\n    /**\n     * For the columns between the gap we took `key` from and the `position`\n     * we want to place that column, which direction do we move those middle columns?\n     */\n    let direction =\n      currentPosition < position\n        ? /**\n           *   moved ------------------> to the right\n           * currentPosition         position\n           *   gap ^\n           * columns left of position now need to shift left to fill that gap\n           */\n          'left'\n        : /**\n           *   moved <------------------ to the left\n           * position         currentPosition\n           *                    gap ^\n           * columns right of position now need to shift right to fill that gap\n           */\n          'right';\n\n    let keyByPosition = new Map<number, string>(\n      [...this.orderedMap.entries()].map((entry) => entry.reverse() as [number, string])\n    );\n\n    for (let [existingPosition, key] of keyByPosition.entries()) {\n      if (direction === 'left') {\n        if (existingPosition > currentPosition && existingPosition <= position) {\n          this.map.set(key, existingPosition - 1);\n        }\n      }\n\n      if (direction === 'right') {\n        if (existingPosition >= position && existingPosition <= currentPosition) {\n          this.map.set(key, existingPosition + 1);\n        }\n      }\n    }\n\n    /**\n     * Finally, set the position for the requested column\n     */\n    this.map.set(key, position);\n\n    /**\n     * Now that we've set the value for one column,\n     * we need to make sure that all columns have a recorded position.\n     */\n    for (let [key, position] of this.orderedMap.entries()) {\n      if (this.map.has(key)) continue;\n\n      this.map.set(key, position);\n    }\n\n    this.args.save(this.map);\n  }\n\n  @action\n  get(key: string) {\n    let result = this.orderedMap.get(key);\n\n    assert(\n      `No position found for ${key}. Is the column used within this table?`,\n      /* 0 is falsey, but it's a valid value for position */\n      undefined !== result\n    );\n\n    return result;\n  }\n\n  /**\n   * The same as this.map, but with all the columns' information\n   */\n  @cached\n  get orderedMap(): ReadonlyMap<string, number> {\n    return orderOf(this.args.columns(), this.map);\n  }\n\n  /**\n   * When columns are removed or hidden, our positions don't change\n   * but when doing the math, we want to adjust things based on 0-indexed counting\n   *\n   * TODO: figure out if we need this??\n   */\n  @cached\n  get adjustedColumns(): Column[] {\n    return [];\n  }\n\n  @cached\n  get orderedColumns(): Column[] {\n    let availableColumns = this.args.columns();\n    let availableByKey = availableColumns.reduce((keyMap, column) => {\n      keyMap[column.key] = column;\n\n      return keyMap;\n    }, {} as Record<string, Column>);\n    let mergedOrder = orderOf(availableColumns, this.map);\n\n    let result: Column[] = Array.from({ length: availableColumns.length });\n\n    for (let [key, position] of mergedOrder.entries()) {\n      let column = availableByKey[key];\n\n      assert(`Could not find column for pair: ${key} @ @{position}`, column);\n      result[position] = column;\n    }\n\n    assert(\n      `Generated orderedColumns' length (${result.filter(Boolean).length}) ` +\n        `does not match the length of available columns (${availableColumns.length}). ` +\n        `orderedColumns: ${result\n          .filter(Boolean)\n          .map((c) => c.key)\n          .join(', ')} -- ` +\n        `available columns: ${availableColumns.map((c) => c.key).join(', ')}`,\n      result.filter(Boolean).length === availableColumns.length\n    );\n\n    return result.filter(Boolean);\n  }\n}\n\n/**\n * @private\n *\n * Utility for helping determine the percieved order of a set of columns\n * given the original (default) ordering, and then user-configurations\n */\nexport function orderOf(\n  columns: { key: string }[],\n  currentOrder: Map<string, number>\n): Map<string, number> {\n  let result = new Map<string, number>();\n  let availableColumns = columns.map((column) => column.key);\n  let availableSet = new Set(availableColumns);\n  let current = new Map<number, string>(\n    [...currentOrder.entries()].map(([key, position]) => [position, key])\n  );\n\n  /**\n   * O(n * log(n)) ?\n   */\n  for (let i = 0; i < Math.max(columns.length, current.size); i++) {\n    let orderedKey = current.get(i);\n\n    if (orderedKey) {\n      /**\n       * If the currentOrder specifies columns not presently available,\n       * ignore them\n       */\n      if (availableSet.has(orderedKey)) {\n        result.set(orderedKey, i);\n        continue;\n      }\n    }\n\n    let availableKey: string | undefined;\n\n    while ((availableKey = availableColumns.shift())) {\n      if (result.has(availableKey) || currentOrder.has(availableKey)) {\n        continue;\n      }\n\n      break;\n    }\n\n    if (!availableKey) {\n      /**\n       * The rest of our columns likely have their order set\n       */\n      continue;\n    }\n\n    result.set(availableKey, i);\n  }\n\n  return result;\n}\n"],"names":["ColumnReordering","BasePlugin","column","ColumnMeta","table","TableMeta","reset","tableMeta","meta","forTable","columns","constructor","position","getPosition","value","setPosition","canMoveLeft","canMoveRight","length","cannotMoveLeft","cannotMoveRight","columnOrder","get","key","newPosition","set","preferences","delete","ColumnOrder","availableColumns","save","map","order","entries","read","Map","Object","orderedColumns","for","tracked","existingOrder","action","args","TrackedMap","maxPosition","currentPosition","orderedMap","assert","entry","join","size","undefined","direction","keyByPosition","reverse","existingPosition","has","result","orderOf","adjustedColumns","availableByKey","reduce","keyMap","mergedOrder","Array","from","filter","Boolean","c","cached","currentOrder","availableSet","Set","current","i","Math","max","orderedKey","availableKey","shift"],"mappings":"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"}
+{"version":3,"file":"plugin.js","sources":["../../../src/plugins/column-reordering/plugin.ts"],"sourcesContent":["import { cached, tracked } from '@glimmer/tracking';\nimport { assert } from '@ember/debug';\nimport { action } from '@ember/object';\n\nimport { TrackedMap } from 'tracked-built-ins';\n\nimport { preferences } from '[public-plugin-types]';\n\nimport { BasePlugin, columns, meta } from '../-private/base';\n\nimport type { PluginPreferences } from '[public-plugin-types]';\nimport type { Column, Table } from '[public-types]';\n\ninterface ColumnReorderingPreferences extends PluginPreferences {\n  table: {\n    order?: Record<string, number>;\n  };\n}\n\ndeclare module 'ember-headless-table/plugins' {\n  interface Registry {\n    ColumnReordering?: ColumnReorderingPreferences;\n  }\n}\n\nexport interface Signature {\n  Meta: {\n    Column: ColumnMeta;\n    Table: TableMeta;\n  };\n}\n\nexport class ColumnReordering extends BasePlugin<Signature> {\n  name = 'column-reordering';\n  static features = ['columnOrder'];\n\n  meta = {\n    column: ColumnMeta,\n    table: TableMeta,\n  } as const;\n\n  reset() {\n    let tableMeta = meta.forTable(this.table, ColumnReordering);\n\n    tableMeta.reset();\n  }\n\n  get columns() {\n    return meta.forTable(this.table, ColumnReordering).columns;\n  }\n}\n\nexport class ColumnMeta {\n  constructor(private column: Column) {}\n\n  get #tableMeta() {\n    return meta.forTable(this.column.table, ColumnReordering);\n  }\n\n  get position() {\n    return this.#tableMeta.getPosition(this.column);\n  }\n\n  set position(value: number) {\n    this.#tableMeta.setPosition(this.column, value);\n  }\n\n  get canMoveLeft() {\n    return this.#tableMeta.getPosition(this.column) !== 0;\n  }\n\n  get canMoveRight() {\n    return this.#tableMeta.getPosition(this.column) !== this.#tableMeta.columns.length - 1;\n  }\n\n  get cannotMoveLeft() {\n    return !this.canMoveLeft;\n  }\n\n  get cannotMoveRight() {\n    return !this.canMoveRight;\n  }\n\n  /**\n   * Move the column one spot to the left\n   */\n  moveLeft = () => {\n    this.#tableMeta.columnOrder.moveLeft(this.column.key);\n  };\n\n  /**\n   * Move the column one spot to the right\n   */\n  moveRight = () => {\n    this.#tableMeta.columnOrder.moveRight(this.column.key);\n  };\n}\n\nexport class TableMeta {\n  constructor(private table: Table) {}\n\n  /**\n   * @private\n   *\n   * We want to maintain the instance of this ColumnOrder class because\n   * we allow the consumer of the table to swap out columns at any time.\n   * When they do this, we want to maintain the order of the table, best we can.\n   * This is also why the order of the columns is maintained via column key\n   */\n  @tracked\n  columnOrder = new ColumnOrder({\n    columns: () => this.availableColumns,\n    save: this.save,\n    existingOrder: this.read(),\n  });\n\n  /**\n   * Get the curret order/position of a column\n   */\n  @action\n  getPosition(column: Column) {\n    return this.columnOrder.get(column.key);\n  }\n\n  /**\n   * Swap the column with the column at `newPosition`\n   */\n  @action\n  setPosition(column: Column, newPosition: number) {\n    return this.columnOrder.swapWith(column.key, newPosition);\n  }\n\n  /**\n   * Using a `ColumnOrder` instance, set the order of all columns\n   */\n  setOrder = (order: ColumnOrder) => {\n    this.columnOrder.setAll(order.map);\n  };\n\n  /**\n   * Revert to default config, delete preferences,\n   * and clear the columnOrder\n   */\n  @action\n  reset() {\n    preferences.forTable(this.table, ColumnReordering).delete('order');\n    this.columnOrder = new ColumnOrder({\n      columns: () => this.availableColumns,\n      save: this.save,\n    });\n  }\n\n  /**\n   * @private\n   */\n  @action\n  save(map: Map<string, number>) {\n    let order: Record<string, number> = {};\n\n    for (let [key, position] of map.entries()) {\n      order[key] = position;\n    }\n\n    preferences.forTable(this.table, ColumnReordering).set('order', order);\n  }\n\n  /**\n   * @private\n   */\n  @action\n  private read() {\n    let order = preferences.forTable(this.table, ColumnReordering).get('order');\n\n    if (!order) return;\n\n    return new Map<string, number>(Object.entries(order));\n  }\n\n  get columns() {\n    return this.columnOrder.orderedColumns;\n  }\n\n  /**\n   * @private\n   * This isn't our data to expose, but it is useful to alias\n   */\n  private get availableColumns() {\n    return columns.for(this.table, ColumnReordering);\n  }\n}\n\n/**\n * @private\n * Used for keeping track of and updating column order\n */\nexport class ColumnOrder {\n  /**\n   * This map will be empty until we re-order something.\n   */\n  map = new TrackedMap<string, number>();\n\n  constructor(\n    private args: {\n      columns: () => Column[];\n      save?: (order: Map<string, number>) => void;\n      existingOrder?: Map<string, number>;\n    }\n  ) {\n    if (args.existingOrder) {\n      this.map = new TrackedMap(args.existingOrder);\n    }\n  }\n\n  /**\n   * To account for columnVisibilty, we need to:\n   * - get the list of visible columns\n   * - get the column order (which preserves the order of hidden columns)\n   * - skip over non-visible columns when determining the previous \"index\"\n   * - set the position to whatever that is.\n   */\n  @action\n  moveLeft(key: string) {\n    let orderedColumns = this.orderedColumns;\n\n    let found = false;\n    let nextColumn: { key: string } | undefined;\n\n    for (let column of orderedColumns.reverse()) {\n      if (found) {\n        nextColumn = column;\n\n        break;\n      }\n\n      if (column.key === key) {\n        found = true;\n      }\n    }\n\n    if (!nextColumn) return;\n\n    let nextPosition = this.get(nextColumn.key);\n\n    this.swapWith(key, nextPosition);\n  }\n\n  setAll = (map: Map<string, number>) => {\n    this.map.clear();\n\n    for (let [key, value] of map.entries()) {\n      this.map.set(key, value);\n    }\n  };\n\n  /**\n   * To account for columnVisibilty, we need to:\n   * - get the list of visible columns\n   * - get the column order (which preserves the order of hidden columns)\n   * - skip over non-visible columns when determining the next \"index\"\n   * - set the position to whatever that is.\n   */\n  @action\n  moveRight(key: string) {\n    let orderedColumns = this.orderedColumns;\n\n    let found = false;\n    let nextColumn: { key: string } | undefined;\n\n    for (let column of orderedColumns) {\n      if (found) {\n        nextColumn = column;\n\n        break;\n      }\n\n      if (column.key === key) {\n        found = true;\n      }\n    }\n\n    if (!nextColumn) return;\n\n    let nextPosition = this.get(nextColumn.key);\n\n    this.swapWith(key, nextPosition);\n  }\n\n  /**\n   * Performs a swap of the column's position with the column at position\n   */\n  @action\n  swapWith(key: string, position: number) {\n    let validPositions = [...this.orderedMap.values()];\n\n    /**\n     * Position to swap to must exist\n     */\n    if (!validPositions.includes(position)) {\n      return;\n    }\n\n    /**\n     * Where did this column `key` come from? we can find out\n     * by reading orderedMap\n     */\n    let currentPosition = this.orderedMap.get(key);\n\n    assert(\n      `Pre-existing position for ${key} could not be found. Does the column exist? ` +\n        `The current positions are: ` +\n        [...this.orderedMap.entries()].map((entry) => entry.join(' => ')).join(', ') +\n        ` and the availableColumns are: ` +\n        this.args.columns().map((column) => column.key) +\n        ` and current \"map\" (${this.map.size}) is: ` +\n        [...this.map.entries()].map((entry) => entry.join(' => ')).join(', '),\n      undefined !== currentPosition\n    );\n\n    /**\n     * No need to change anything if the position is the same\n     * This helps reduce @tracked invalidations, which in turn reduces DOM thrashing.\n     */\n    if (currentPosition === position) {\n      return false;\n    }\n\n    let keyByPosition = new Map<number, string>(\n      [...this.orderedMap.entries()].map((entry) => entry.reverse() as [number, string])\n    );\n\n    for (let [existingPosition, key] of keyByPosition.entries()) {\n      if (existingPosition === position) {\n        /**\n         * We swap positions because the positions are not incremental\n         * meaning we can have gaps, intentionally, due to hidden columns\n         */\n        this.map.set(key, currentPosition);\n\n        break;\n      }\n    }\n\n    /**\n     * Finally, set the position for the requested column\n     */\n    this.map.set(key, position);\n\n    /**\n     * Now that we've set the value for one column,\n     * we need to make sure that all columns have a recorded position.\n     */\n    for (let [key, position] of this.orderedMap.entries()) {\n      if (this.map.has(key)) continue;\n\n      this.map.set(key, position);\n    }\n\n    this.args.save?.(this.map);\n  }\n\n  @action\n  get(key: string) {\n    let result = this.orderedMap.get(key);\n\n    assert(\n      `No position found for ${key}. Is the column used within this table?`,\n      /* 0 is falsey, but it's a valid value for position */\n      undefined !== result\n    );\n\n    return result;\n  }\n\n  /**\n   * The same as this.map, but with all the columns' information\n   */\n  @cached\n  get orderedMap(): ReadonlyMap<string, number> {\n    return orderOf(this.args.columns(), this.map);\n  }\n\n  @cached\n  get orderedColumns(): Column[] {\n    let availableColumns = this.args.columns();\n    let availableByKey = availableColumns.reduce((keyMap, column) => {\n      keyMap[column.key] = column;\n\n      return keyMap;\n    }, {} as Record<string, Column>);\n    let mergedOrder = orderOf(availableColumns, this.map);\n\n    let result: Column[] = Array.from({ length: availableColumns.length });\n\n    for (let [key, position] of mergedOrder.entries()) {\n      let column = availableByKey[key];\n\n      assert(`Could not find column for pair: ${key} @ @{position}`, column);\n      result[position] = column;\n    }\n\n    assert(\n      `Generated orderedColumns' length (${result.filter(Boolean).length}) ` +\n        `does not match the length of available columns (${availableColumns.length}). ` +\n        `orderedColumns: ${result\n          .filter(Boolean)\n          .map((c) => c.key)\n          .join(', ')} -- ` +\n        `available columns: ${availableColumns.map((c) => c.key).join(', ')}`,\n      result.filter(Boolean).length === availableColumns.length\n    );\n\n    return result.filter(Boolean);\n  }\n}\n\n/**\n * @private\n *\n * Utility for helping determine the percieved order of a set of columns\n * given the original (default) ordering, and then user-configurations\n */\nexport function orderOf(\n  columns: { key: string }[],\n  currentOrder: Map<string, number>\n): Map<string, number> {\n  let result = new Map<string, number>();\n  let availableColumns = columns.map((column) => column.key);\n  let availableSet = new Set(availableColumns);\n  let current = new Map<number, string>(\n    [...currentOrder.entries()].map(([key, position]) => [position, key])\n  );\n\n  /**\n   * O(n * log(n)) ?\n   */\n  for (let i = 0; i < Math.max(columns.length, current.size); i++) {\n    let orderedKey = current.get(i);\n\n    if (orderedKey) {\n      /**\n       * If the currentOrder specifies columns not presently available,\n       * ignore them\n       */\n      if (availableSet.has(orderedKey)) {\n        result.set(orderedKey, i);\n        continue;\n      }\n    }\n\n    let availableKey: string | undefined;\n\n    while ((availableKey = availableColumns.shift())) {\n      if (result.has(availableKey) || currentOrder.has(availableKey)) {\n        continue;\n      }\n\n      break;\n    }\n\n    if (!availableKey) {\n      /**\n       * The rest of our columns likely have their order set\n       */\n      continue;\n    }\n\n    result.set(availableKey, i);\n  }\n\n  return result;\n}\n"],"names":["ColumnReordering","BasePlugin","column","ColumnMeta","table","TableMeta","reset","tableMeta","meta","forTable","columns","constructor","columnOrder","moveLeft","key","moveRight","position","getPosition","value","setPosition","canMoveLeft","canMoveRight","length","cannotMoveLeft","cannotMoveRight","order","setAll","map","get","newPosition","swapWith","preferences","delete","ColumnOrder","availableColumns","save","entries","set","read","Map","Object","orderedColumns","for","tracked","existingOrder","action","args","TrackedMap","clear","found","nextColumn","reverse","nextPosition","validPositions","orderedMap","values","includes","currentPosition","assert","entry","join","size","undefined","keyByPosition","existingPosition","has","result","orderOf","availableByKey","reduce","keyMap","mergedOrder","Array","from","filter","Boolean","c","cached","currentOrder","availableSet","Set","current","i","Math","max","orderedKey","availableKey","shift"],"mappings":"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"}

package/dist/plugins/column-reordering/utils.js

@@ -5,34 +5,27 @@ function reorderColumns(columns, orderedColumns) {
   if (orderedColumns === undefined) {
     return columns;
   }
-
   let repositionedColumns = Array.from({
     length: columns.length
   });
-
   for (const column of columns) {
     const orderedColumn = orderedColumns.find(orderedColumn => column.key === orderedColumn.key);
     const currentMeta = meta.forColumn(column, ColumnReordering);
-
     if (orderedColumn === undefined) {
       if (currentMeta.position !== undefined && currentMeta.position >= 0) {
         repositionedColumns[currentMeta.position] = column;
       }
-
       continue;
     }
-
     const {
       position
     } = orderedColumn;
-
     if (position !== undefined && !repositionedColumns[position]) {
       repositionedColumns[position] = column;
     } else {
       repositionedColumns.push(column);
     }
   }
-
   repositionedColumns = repositionedColumns.filter(column => column !== undefined);
   return repositionedColumns;
 }

package/dist/plugins/column-reordering/utils.js.map

@@ -1 +1 @@
-{"version":3,"file":"utils.js","sources":["../../../src/plugins/column-reordering/utils.ts"],"sourcesContent":["import { meta } from '../-private/base';\nimport { ColumnReordering } from './plugin';\n\nimport type { Column } from '[public-types]';\n\ntype ColumnOrder = { key: string; position: number | undefined }[];\n\nexport function reorderColumns(columns: Column[], orderedColumns: ColumnOrder | undefined) {\n  if (orderedColumns === undefined) {\n    return columns;\n  }\n\n  let repositionedColumns: Column[] = Array.from({\n    length: columns.length,\n  });\n\n  for (const column of columns) {\n    const orderedColumn = orderedColumns.find((orderedColumn) => column.key === orderedColumn.key);\n    const currentMeta = meta.forColumn(column, ColumnReordering);\n\n    if (orderedColumn === undefined) {\n      if (currentMeta.position !== undefined && currentMeta.position >= 0) {\n        repositionedColumns[currentMeta.position] = column;\n      }\n\n      continue;\n    }\n\n    const { position } = orderedColumn;\n\n    if (position !== undefined && !repositionedColumns[position]) {\n      repositionedColumns[position] = column;\n    } else {\n      repositionedColumns.push(column);\n    }\n  }\n\n  repositionedColumns = repositionedColumns.filter((column) => column !== undefined);\n\n  return repositionedColumns;\n}\n"],"names":["reorderColumns","columns","orderedColumns","undefined","repositionedColumns","Array","from","length","column","orderedColumn","find","key","currentMeta","meta","forColumn","ColumnReordering","position","push","filter"],"mappings":";;;AAOO,SAASA,cAAT,CAAwBC,OAAxB,EAA2CC,cAA3C,EAAoF;EACzF,IAAIA,cAAc,KAAKC,SAAvB,EAAkC;AAChC,IAAA,OAAOF,OAAP,CAAA;AACD,GAAA;;AAED,EAAA,IAAIG,mBAA6B,GAAGC,KAAK,CAACC,IAAN,CAAW;IAC7CC,MAAM,EAAEN,OAAO,CAACM,MAAAA;AAD6B,GAAX,CAApC,CAAA;;AAIA,EAAA,KAAK,MAAMC,MAAX,IAAqBP,OAArB,EAA8B;AAC5B,IAAA,MAAMQ,aAAa,GAAGP,cAAc,CAACQ,IAAf,CAAqBD,aAAD,IAAmBD,MAAM,CAACG,GAAP,KAAeF,aAAa,CAACE,GAApE,CAAtB,CAAA;IACA,MAAMC,WAAW,GAAGC,IAAI,CAACC,SAAL,CAAeN,MAAf,EAAuBO,gBAAvB,CAApB,CAAA;;IAEA,IAAIN,aAAa,KAAKN,SAAtB,EAAiC;MAC/B,IAAIS,WAAW,CAACI,QAAZ,KAAyBb,SAAzB,IAAsCS,WAAW,CAACI,QAAZ,IAAwB,CAAlE,EAAqE;AACnEZ,QAAAA,mBAAmB,CAACQ,WAAW,CAACI,QAAb,CAAnB,GAA4CR,MAA5C,CAAA;AACD,OAAA;;AAED,MAAA,SAAA;AACD,KAAA;;IAED,MAAM;AAAEQ,MAAAA,QAAAA;AAAF,KAAA,GAAeP,aAArB,CAAA;;IAEA,IAAIO,QAAQ,KAAKb,SAAb,IAA0B,CAACC,mBAAmB,CAACY,QAAD,CAAlD,EAA8D;AAC5DZ,MAAAA,mBAAmB,CAACY,QAAD,CAAnB,GAAgCR,MAAhC,CAAA;AACD,KAFD,MAEO;MACLJ,mBAAmB,CAACa,IAApB,CAAyBT,MAAzB,CAAA,CAAA;AACD,KAAA;AACF,GAAA;;EAEDJ,mBAAmB,GAAGA,mBAAmB,CAACc,MAApB,CAA4BV,MAAD,IAAYA,MAAM,KAAKL,SAAlD,CAAtB,CAAA;AAEA,EAAA,OAAOC,mBAAP,CAAA;AACD;;;;"}
+{"version":3,"file":"utils.js","sources":["../../../src/plugins/column-reordering/utils.ts"],"sourcesContent":["import { meta } from '../-private/base';\nimport { ColumnReordering } from './plugin';\n\nimport type { Column } from '[public-types]';\n\ntype ColumnOrder = { key: string; position: number | undefined }[];\n\nexport function reorderColumns(columns: Column[], orderedColumns: ColumnOrder | undefined) {\n  if (orderedColumns === undefined) {\n    return columns;\n  }\n\n  let repositionedColumns: Column[] = Array.from({\n    length: columns.length,\n  });\n\n  for (const column of columns) {\n    const orderedColumn = orderedColumns.find((orderedColumn) => column.key === orderedColumn.key);\n    const currentMeta = meta.forColumn(column, ColumnReordering);\n\n    if (orderedColumn === undefined) {\n      if (currentMeta.position !== undefined && currentMeta.position >= 0) {\n        repositionedColumns[currentMeta.position] = column;\n      }\n\n      continue;\n    }\n\n    const { position } = orderedColumn;\n\n    if (position !== undefined && !repositionedColumns[position]) {\n      repositionedColumns[position] = column;\n    } else {\n      repositionedColumns.push(column);\n    }\n  }\n\n  repositionedColumns = repositionedColumns.filter((column) => column !== undefined);\n\n  return repositionedColumns;\n}\n"],"names":["reorderColumns","columns","orderedColumns","undefined","repositionedColumns","Array","from","length","column","orderedColumn","find","key","currentMeta","meta","forColumn","ColumnReordering","position","push","filter"],"mappings":";;;AAOO,SAASA,cAAc,CAACC,OAAiB,EAAEC,cAAuC,EAAE;EACzF,IAAIA,cAAc,KAAKC,SAAS,EAAE;AAChC,IAAA,OAAOF,OAAO,CAAA;AAChB,GAAA;AAEA,EAAA,IAAIG,mBAA6B,GAAGC,KAAK,CAACC,IAAI,CAAC;IAC7CC,MAAM,EAAEN,OAAO,CAACM,MAAAA;AAClB,GAAC,CAAC,CAAA;AAEF,EAAA,KAAK,MAAMC,MAAM,IAAIP,OAAO,EAAE;AAC5B,IAAA,MAAMQ,aAAa,GAAGP,cAAc,CAACQ,IAAI,CAAED,aAAa,IAAKD,MAAM,CAACG,GAAG,KAAKF,aAAa,CAACE,GAAG,CAAC,CAAA;IAC9F,MAAMC,WAAW,GAAGC,IAAI,CAACC,SAAS,CAACN,MAAM,EAAEO,gBAAgB,CAAC,CAAA;IAE5D,IAAIN,aAAa,KAAKN,SAAS,EAAE;MAC/B,IAAIS,WAAW,CAACI,QAAQ,KAAKb,SAAS,IAAIS,WAAW,CAACI,QAAQ,IAAI,CAAC,EAAE;AACnEZ,QAAAA,mBAAmB,CAACQ,WAAW,CAACI,QAAQ,CAAC,GAAGR,MAAM,CAAA;AACpD,OAAA;AAEA,MAAA,SAAA;AACF,KAAA;IAEA,MAAM;AAAEQ,MAAAA,QAAAA;AAAS,KAAC,GAAGP,aAAa,CAAA;IAElC,IAAIO,QAAQ,KAAKb,SAAS,IAAI,CAACC,mBAAmB,CAACY,QAAQ,CAAC,EAAE;AAC5DZ,MAAAA,mBAAmB,CAACY,QAAQ,CAAC,GAAGR,MAAM,CAAA;AACxC,KAAC,MAAM;AACLJ,MAAAA,mBAAmB,CAACa,IAAI,CAACT,MAAM,CAAC,CAAA;AAClC,KAAA;AACF,GAAA;EAEAJ,mBAAmB,GAAGA,mBAAmB,CAACc,MAAM,CAAEV,MAAM,IAAKA,MAAM,KAAKL,SAAS,CAAC,CAAA;AAElF,EAAA,OAAOC,mBAAmB,CAAA;AAC5B;;;;"}