ember-headless-table 0.0.0 → 1.0.1

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

@@ -0,0 +1,392 @@
+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 { macroCondition, dependencySatisfies, importSync } from '@embroider/macros';
+import { tracked } from '@glimmer/tracking';
+import { assert } from '@ember/debug';
+import { action } from '@ember/object';
+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++);
+
+    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);
+
+    this.table = table;
+  }
+  /**
+   * @private
+   *
+   * We want to maintain the instance of this ColumnOrder class because
+   * we allow the consumer of the table to swap out columns at any time.
+   * When they do this, we want to maintain the order of the table, best we can.
+   * This is also why the order of the columns is maintained via column key
+   */
+
+
+  getPosition(column) {
+    return this.columnOrder.get(column.key);
+  }
+
+  setPosition(column, newPosition) {
+    return this.columnOrder.set(column.key, newPosition);
+  }
+  /**
+   * Revert to default config, delete preferences,
+   * and clear the columnOrder
+   */
+
+
+  reset() {
+    preferences.forTable(this.table, ColumnReordering).delete('order');
+    this.columnOrder = new ColumnOrder({
+      columns: () => this.availableColumns,
+      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,
+  writable: true,
+  initializer: function () {
+    return new ColumnOrder({
+      columns: () => this.availableColumns,
+      save: this.save,
+      existingOrder: this.read()
+    });
+  }
+}), _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());
+
+    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;
+    }
+    /**
+     * position is 0-indexed and length includes 0 in its count of items
+     */
+
+
+    let maxPosition = this.args.columns().length - 1;
+    /**
+     * Cannot set a position higher than the max value (after the end?)
+     */
+
+    if (position > maxPosition) {
+      return false;
+    }
+    /**
+     * 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);
+        }
+      }
+    }
+    /**
+     * 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);
+  }
+
+  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 */
+    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) => {
+      keyMap[column.key] = column;
+      return keyMap;
+    }, {});
+    let mergedOrder = orderOf(availableColumns, this.map);
+    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, "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,
+       * ignore them
+       */
+      if (availableSet.has(orderedKey)) {
+        result.set(orderedKey, i);
+        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;
+}
+
+export { ColumnMeta, ColumnOrder, ColumnReordering, TableMeta, orderOf };
+//# sourceMappingURL=plugin.js.map

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

@@ -0,0 +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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"}

package/dist/plugins/column-reordering/utils.d.ts

@@ -0,0 +1,7 @@
+import { Column } from "../../index";
+type ColumnOrder = {
+    key: string;
+    position: number | undefined;
+}[];
+declare function reorderColumns(columns: Column[], orderedColumns: ColumnOrder | undefined): Column<unknown>[];
+export { reorderColumns };

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

@@ -0,0 +1,41 @@
+import { meta } from '../-private/base.js';
+import { ColumnReordering } from './plugin.js';
+
+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;
+}
+
+export { reorderColumns };
+//# sourceMappingURL=utils.js.map

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

@@ -0,0 +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;;;;"}

package/dist/plugins/column-resizing/handle.d.ts

@@ -0,0 +1,116 @@
+import Modifier from 'ember-modifier';
+import { ColumnMeta } from "./plugin";
+import { Column } from "../../-private/column";
+/**
+ * - why are mouse events used instead of drag events?
+ * - why not use the "draggable" attribute?
+ *
+ * It seems drag events are more for files and/or moving images around on a page
+ * dragging an image, for example, has a ghost of that image until it is dropped.
+ * The same thing happens with text.
+ * This prevents us from having total control of the styling of how dragging works.
+ *
+ *
+ *
+ */
+declare class ResizeHandle extends Modifier<{
+    Args: {
+        Positional: [Column];
+    };
+}> {
+    dragHandle: HTMLElement;
+    column: Column;
+    meta: ColumnMeta;
+    pointerStartX: number;
+    pointerStartY: number;
+    pointerX: number;
+    pointerY: number;
+    dragFrame: number;
+    keyDistance: number;
+    keyFrame: number;
+    lastKey: number;
+    token?: unknown;
+    isSetup: boolean;
+    modify(element: Element, [column]: [Column]): void;
+    setup: () => void;
+    setPosition: (event: Event) => void;
+    setStartPosition: (event: Event) => void;
+    queueUpdate: () => void;
+    dragEndHandler: () => void;
+    dragMove: (event: Event) => void;
+    dragStartHandler: (event: Event) => void;
+    keyHandler: (event: KeyboardEvent) => void;
+}
+/**
+ * Modifier to attach to the column resize handles.
+ * This provides both keyboard and mouse support for resizing columns.
+ * (provided the resize handle element is focusable -- so consider using
+ * a button for the resize element)
+ *
+ * @example
+ * ```js
+ * import Component from '@glimmer/component';
+ * import { meta } from 'ember-headless-table/plugins';
+ * import { resizeHandle, ColumnResizing } from 'ember-headless-table/plugins/column-resizing';
+ *
+ * export default class TableHead extends Component {
+ *   /* ✂️  *\/
+ *
+ *   <template>
+ *     <thead>
+ *       <tr>
+ *         {{#each this.columns as |column|}}
+ *           <th>
+ *             <span>{{column.name}}</span>
+ *             <button {{resizeHandle column}}></button>
+ *           </th>
+ *         {{/each}}
+ *       </tr>
+ *     </thead>
+ *   </template>
+ * }
+ * ```
+ *
+ * Width and isResizing state is maintained on the "meta"
+ * class so that the users may choose per-column stylings for
+ * isResizing and dragging behaviors.
+ *
+ * For example, while dragging, the user may add a class based on the
+ * isDragging property.
+ *
+ * @example
+ * ```js
+ * import Component from '@glimmer/component';
+ * import { meta } from 'ember-headless-table/plugins';
+ * import { resizeHandle, ColumnResizing } from 'ember-headless-table/plugins/column-resizing';
+ *
+ * export default class TableHead extends Component {
+ *   /* ✂️  *\/
+ *
+ *   isDragging = (column) => {
+ *     return meta.forColumn(column, ColumnResizing).isDragging;
+ *   }
+ *
+ *   <template>
+ *     <thead>
+ *       <tr>
+ *         {{#each this.columns as |column|}}
+ *           <th class="header {{if (this.isDragging column) 'blue'}}">
+ *             <span>{{column.name}}</span>
+ *             <button {{resizeHandle column}}></button>
+ *           </th>
+ *         {{/each}}
+ *       </tr>
+ *     </thead>
+ *   </template>
+ * }
+ * ```
+ *
+ *
+ * @note
+ * The logic here is copied from the drag slider in
+ * https://limber.glimdown.com/
+ * See: "resize-handle" on Limber's GitHub
+ */
+declare const resizeHandle: typeof ResizeHandle;
+export { resizeHandle };