@bennerinformatics/ember-fw-table 2.1.2 → 2.1.4

package/.yalc/ember-sortable/addon/services/ember-sortable.js

@@ -0,0 +1,92 @@
+import Service from '@ember/service';
+
+export default class EmberSortableService extends Service {
+  /**
+   * Internal State for any groups currently in DOM
+   *
+   * {
+   *   groupName: {
+   *     groupModifier: object,
+   *     items: []
+   *   }
+   * }
+   * @type {{}}
+   */
+  groups = {};
+
+  /**
+   * Register a new group with the service
+   *
+   * @param {String} groupName
+   * @param {SortableGroupModifier} groupModifier
+   */
+  registerGroup(groupName, groupModifier) {
+    if (this.groups[groupName] === undefined) {
+      this.groups[groupName] = {
+        groupModifier: groupModifier,
+        items: [],
+      };
+    } else {
+      this.groups[groupName].groupModifier = groupModifier;
+    }
+  }
+
+  /**
+   * De-register a group with the service
+   *
+   * @param {String} groupName
+   */
+  deregisterGroup(groupName) {
+    delete this.groups[groupName];
+  }
+
+  /**
+   * Register an item with this group
+   *
+   * @method registerItem
+   * @param {String} groupName
+   * @param {SortableItemModifier} item
+   */
+  registerItem(groupName, item) {
+    let groupDef = this.fetchGroup(groupName);
+    let items = groupDef.items;
+
+    if (items.indexOf(item) === -1) {
+      items = [...items, item];
+    }
+
+    groupDef.items = items;
+  }
+
+  /**
+   De-register an item with this group.
+
+   @method deregisterItem
+   @param groupName
+   @param item
+   */
+  deregisterItem(groupName, item) {
+    let groupDef = this.fetchGroup(groupName);
+    let items = groupDef.items;
+
+    const index = items.indexOf(item);
+    if (index !== -1) {
+      let newItems = [...items.slice(0, index), ...items.slice(index + 1)];
+      groupDef.items = newItems;
+    }
+  }
+
+  /**
+   * Fetch a group definition
+   *
+   * @param {String} groupName
+   * @returns {*}
+   */
+  fetchGroup(groupName) {
+    if (this.groups[groupName] === undefined) {
+      this.registerGroup(groupName, undefined);
+    }
+
+    return this.groups[groupName];
+  }
+}

package/.yalc/ember-sortable/addon/system/scroll-container.js

@@ -0,0 +1,53 @@
+export default class ScrollContainer {
+  constructor(element) {
+    this.isWindow = element === document;
+    this.element = this.isWindow ? document.documentElement : element;
+
+    if (this.isWindow) {
+      this.top = 0;
+      this.left = 0;
+      this.width = document.documentElement.clientWidth;
+      this.height = document.documentElement.clientHeight;
+    } else {
+      // Absolute position in document
+      let { top, left } = this.element.getBoundingClientRect();
+      this.top = top;
+      this.left = left;
+      // Viewport size of the container element
+      this.width = parseFloat(getComputedStyle(this.element).width);
+      this.height = parseFloat(getComputedStyle(this.element).height);
+    }
+    // Total size of the container element (including scrollable part)
+    this.scrollWidth = this.element.scrollWidth;
+    this.scrollHeight = this.element.scrollHeight;
+    // Max scroll pos
+    this.maxScrollTop = this.scrollHeight - this.height;
+    this.maxScrollLeft = this.scrollWidth - this.width;
+  }
+
+  get bottom() {
+    return this.top + this.height;
+  }
+
+  get right() {
+    return this.left + this.width;
+  }
+
+  scrollTop(value) {
+    if (value) {
+      value = Math.max(0, Math.min(this.maxScrollTop, value));
+      this.element.scrollTop = value;
+      return value;
+    }
+    return this.element.scrollTop;
+  }
+
+  scrollLeft(value) {
+    if (value) {
+      value = Math.max(0, Math.min(this.maxScrollLeft, value));
+      this.element.scrollLeft = value;
+      return value;
+    }
+    return this.element.scrollLeft;
+  }
+}

package/.yalc/ember-sortable/addon/system/scroll-parent.js

@@ -0,0 +1,33 @@
+function getParentElements(element) {
+  const parentsArray = [];
+
+  if (!element) {
+    return parentsArray;
+  }
+
+  let currentParent = element.parentElement;
+
+  while (currentParent !== null) {
+    parentsArray.push(currentParent);
+    currentParent = currentParent.parentElement;
+  }
+  return parentsArray;
+}
+
+export default function (element) {
+  let position = getComputedStyle(element).position;
+  let excludeStaticParent = position === 'absolute';
+  let scrollParent = getParentElements(element).filter(function (parent) {
+    let parentElemStyles = getComputedStyle(parent);
+    if (excludeStaticParent && parentElemStyles.position === 'static') {
+      return false;
+    }
+    let { overflow, overflowX, overflowY } = parentElemStyles;
+    return /(auto|scroll)/.test(overflow + overflowX + overflowY);
+  })[0];
+
+  if (!scrollParent || scrollParent === document.body) {
+    scrollParent = document;
+  }
+  return position === 'fixed' || scrollParent;
+}

package/.yalc/ember-sortable/addon/utils/constant.js

@@ -0,0 +1,9 @@
+export const DRAG_ACTIONS = ['mousemove', 'touchmove'];
+export const ELEMENT_CLICK_ACTION = 'click';
+export const END_ACTIONS = ['click', 'mouseup', 'touchend'];
+export const ANNOUNCEMENT_ACTION_TYPES = {
+  ACTIVATE: 'ACTIVATE',
+  MOVE: 'MOVE',
+  CONFIRM: 'CONFIRM',
+  CANCEL: 'CANCEL',
+};

package/.yalc/ember-sortable/addon/utils/coordinate.js

@@ -0,0 +1,34 @@
+/**
+  Gets the y offset for a given event.
+  Work for touch and mouse events.
+  @method getY
+  @return {Number}
+  @private
+*/
+export function getY(event) {
+  let touches = event.changedTouches;
+  let touch = touches && touches[0];
+
+  if (touch) {
+    return touch.screenY;
+  } else {
+    return event.clientY;
+  }
+}
+
+/**
+  Gets the x offset for a given event.
+  @method getX
+  @return {Number}
+  @private
+*/
+export function getX(event) {
+  let touches = event.changedTouches;
+  let touch = touches && touches[0];
+
+  if (touch) {
+    return touch.screenX;
+  } else {
+    return event.clientX;
+  }
+}

package/.yalc/ember-sortable/addon/utils/css-calculation.js

@@ -0,0 +1,20 @@
+/**
+  Gets a numeric border-spacing values for a given element.
+
+  @method getBorderSpacing
+  @param {Element} element
+  @return {Object}
+  @private
+*/
+export function getBorderSpacing(el) {
+  let css = getComputedStyle(el).borderSpacing; // '0px 0px'
+  let [horizontal, vertical] = css.split(' ');
+  if (vertical === undefined) {
+    vertical = horizontal;
+  }
+
+  return {
+    horizontal: parseFloat(horizontal),
+    vertical: parseFloat(vertical),
+  };
+}

package/.yalc/ember-sortable/addon/utils/defaults.js

@@ -0,0 +1,26 @@
+export const defaultA11yAnnouncementConfig = {
+  ACTIVATE({ a11yItemName, index, maxLength, direction }) {
+    let message = `${a11yItemName} at position, ${index + 1} of ${maxLength}, is activated to be repositioned.`;
+
+    if (direction === 'y') {
+      message += 'Press up and down keys to change position,';
+    } else {
+      message += 'Press left and right keys to change position,';
+    }
+
+    message += ' Space to confirm new position, Escape to cancel.';
+
+    return message;
+  },
+  MOVE({ a11yItemName, index, maxLength, delta }) {
+    return `${a11yItemName} is moved to position, ${
+      index + 1 + delta
+    } of ${maxLength}. Press Space to confirm new position, Escape to cancel.`;
+  },
+  CONFIRM({ a11yItemName }) {
+    return `${a11yItemName} is successfully repositioned.`;
+  },
+  CANCEL({ a11yItemName }) {
+    return `Cancelling ${a11yItemName} repositioning`;
+  },
+};

package/.yalc/ember-sortable/addon/utils/keyboard.js

@@ -0,0 +1,32 @@
+const ENTER_KEY = 'Enter';
+const ESCAPE_KEY = 'Escape';
+const SPACE_KEY = 'Space';
+const ARROW_KEYS = {
+  LEFT: 'ArrowLeft',
+  UP: 'ArrowUp',
+  RIGHT: 'ArrowRight',
+  DOWN: 'ArrowDown',
+};
+export const ENTER_KEY_CODE = 13;
+export const ESCAPE_KEY_CODE = 27;
+export const SPACE_KEY_CODE = 32;
+export const ARROW_KEY_CODES = {
+  LEFT: 37,
+  UP: 38,
+  RIGHT: 39,
+  DOWN: 40,
+};
+
+function createKeyTest(key, keyCode) {
+  return function isKey(event) {
+    return event.key === key || event.keyCode === keyCode;
+  };
+}
+
+export const isEnterKey = createKeyTest(ENTER_KEY, ENTER_KEY_CODE);
+export const isEscapeKey = createKeyTest(ESCAPE_KEY, ESCAPE_KEY_CODE);
+export const isSpaceKey = createKeyTest(SPACE_KEY, SPACE_KEY_CODE);
+export const isLeftArrowKey = createKeyTest(ARROW_KEYS.LEFT, ARROW_KEY_CODES.LEFT);
+export const isUpArrowKey = createKeyTest(ARROW_KEYS.UP, ARROW_KEY_CODES.UP);
+export const isRightArrowKey = createKeyTest(ARROW_KEYS.RIGHT, ARROW_KEY_CODES.RIGHT);
+export const isDownArrowKey = createKeyTest(ARROW_KEYS.DOWN, ARROW_KEY_CODES.DOWN);

package/.yalc/ember-sortable/addon-test-support/helpers/drag.js

@@ -0,0 +1,111 @@
+import { triggerEvent, find, settled } from '@ember/test-helpers';
+import { getOffset } from '../utils/offset';
+
+/**
+  Drags elements by an offset specified in pixels.
+
+  Examples
+
+      drag(
+        'mouse',
+        '.some-list li[data-item=uno]',
+        function() {
+          return { dy: 50, dx: 20 };
+        }
+      );
+
+  @method drag
+  @param {'mouse'|'touch'} [mode]
+    event mode
+  @param {String} [itemSelector]
+    selector for the element to drag
+  @param {Function} [offsetFn]
+    function returning the offset by which to drag
+  @param {Object} [callbacks]
+    callbacks that are fired at the different stages of the interaction
+  @return {Promise}
+*/
+
+export async function drag(mode, itemSelector, offsetFn, callbacks = {}) {
+  let start;
+  let move;
+  let end;
+  let which;
+
+  if (mode === 'mouse') {
+    start = 'mousedown';
+    move = 'mousemove';
+    end = 'mouseup';
+    which = 1;
+  } else if (mode === 'touch') {
+    start = 'touchstart';
+    move = 'touchmove';
+    end = 'touchend';
+  } else {
+    throw new Error(`Unsupported mode: '${mode}'`);
+  }
+
+  const itemElement = find(itemSelector);
+  const itemOffset = getOffset(itemElement);
+  const offset = offsetFn();
+  const rect = itemElement.getBoundingClientRect();
+  // firefox gives some elements, like <svg>, a clientHeight of 0.
+  // we can try to grab it off the parent instead to have a better
+  // guess at what the scale is.
+  // https://bugzilla.mozilla.org/show_bug.cgi?id=874811#c14
+  // https://stackoverflow.com/a/13647345
+  // https://stackoverflow.com/a/5042051
+  const dx = offset.dx || 0;
+  const dy = offset.dy || 0;
+  const clientHeight = itemElement.clientHeight || itemElement.offsetHeight || itemElement.parentNode.offsetHeight;
+  const scale = clientHeight / (rect.bottom - rect.top);
+  const halfwayX = itemOffset.left + (dx * scale) / 2;
+  const halfwayY = itemOffset.top + (dy * scale) / 2;
+  const targetX = itemOffset.left + dx * scale;
+  const targetY = itemOffset.top + dy * scale;
+
+  await triggerEvent(itemElement, start, {
+    clientX: itemOffset.left,
+    clientY: itemOffset.top,
+    which,
+  });
+
+  if (callbacks.dragstart) {
+    await callbacks.dragstart();
+    await settled();
+  }
+
+  await triggerEvent(itemElement, move, {
+    clientX: itemOffset.left,
+    clientY: itemOffset.top,
+  });
+
+  if (callbacks.dragmove) {
+    await callbacks.dragmove();
+    await settled();
+  }
+
+  await triggerEvent(itemElement, move, {
+    clientX: halfwayX,
+    clientY: halfwayY,
+  });
+
+  await triggerEvent(itemElement, move, {
+    clientX: targetX,
+    clientY: targetY,
+  });
+
+  if (callbacks.beforedragend) {
+    await callbacks.beforedragend();
+  }
+
+  await triggerEvent(itemElement, end, {
+    clientX: targetX,
+    clientY: targetY,
+  });
+
+  if (callbacks.dragend) {
+    await callbacks.dragend();
+    await settled();
+  }
+}

package/.yalc/ember-sortable/addon-test-support/helpers/index.js

@@ -0,0 +1,4 @@
+import { drag } from './drag';
+import { reorder } from './reorder';
+
+export { drag, reorder };

package/.yalc/ember-sortable/addon-test-support/helpers/reorder.js

@@ -0,0 +1,41 @@
+import { find, findAll } from '@ember/test-helpers';
+import { drag } from './drag';
+import { getOffset } from '../utils/offset';
+
+const OVERSHOOT = 2;
+
+/**
+  Reorders elements to the specified state.
+
+  Examples
+
+      reorder(
+        'mouse',
+        '.some-list li',
+        '[data-id="66278893"]',
+        '[data-id="66278894"]',
+        '[data-id="66278892"]'
+      );
+
+  @method reorder
+  @param {'mouse'|'touch'} [mode]
+    event mode
+  @param {String} [itemSelector]
+    selector for all items
+  @param {...String} [resultSelectors]
+    selectors for the resultant order
+  @return {Promise}
+*/
+export async function reorder(mode, itemSelector, ...resultSelectors) {
+  for (let targetIndex = 0; targetIndex < resultSelectors.length; targetIndex++) {
+    const items = findAll(itemSelector);
+    const sourceElement = find(resultSelectors[targetIndex]);
+    const targetElement = items[targetIndex];
+    const dx = getOffset(targetElement).left - OVERSHOOT - getOffset(sourceElement).left;
+    const dy = getOffset(targetElement).top - OVERSHOOT - getOffset(sourceElement).top;
+
+    await drag(mode, sourceElement, () => {
+      return { dx: dx, dy: dy };
+    });
+  }
+}

package/.yalc/ember-sortable/addon-test-support/utils/keyboard.js

@@ -0,0 +1,32 @@
+const ENTER_KEY = 'Enter';
+const ESCAPE_KEY = 'Escape';
+const SPACE_KEY = 'Space';
+const ARROW_KEYS = {
+  LEFT: 'ArrowLeft',
+  UP: 'ArrowUp',
+  RIGHT: 'ArrowRight',
+  DOWN: 'ArrowDown',
+};
+export const ENTER_KEY_CODE = 13;
+export const ESCAPE_KEY_CODE = 27;
+export const SPACE_KEY_CODE = 32;
+export const ARROW_KEY_CODES = {
+  LEFT: 37,
+  UP: 38,
+  RIGHT: 39,
+  DOWN: 40,
+};
+
+function createKeyTest(key, keyCode) {
+  return function isKey(event) {
+    return event.key === key || event.keyCode === keyCode;
+  };
+}
+
+export const isEnterKey = createKeyTest(ENTER_KEY, ENTER_KEY_CODE);
+export const isEscapeKey = createKeyTest(ESCAPE_KEY, ESCAPE_KEY_CODE);
+export const isSpaceKey = createKeyTest(SPACE_KEY, SPACE_KEY_CODE);
+export const isLeftArrowKey = createKeyTest(ARROW_KEYS.LEFT, ARROW_KEY_CODES.LEFT);
+export const isUpArrowKey = createKeyTest(ARROW_KEYS.UP, ARROW_KEY_CODES.UP);
+export const isRightArrowKey = createKeyTest(ARROW_KEYS.RIGHT, ARROW_KEY_CODES.RIGHT);
+export const isDownArrowKey = createKeyTest(ARROW_KEYS.DOWN, ARROW_KEY_CODES.DOWN);

package/.yalc/ember-sortable/addon-test-support/utils/offset.js

@@ -0,0 +1,14 @@
+/** Vanilla Javascript equivalent of JQuery's `.offset`.
+ * Reference: https://github.com/nefe/You-Dont-Need-jQuery
+ *
+ * @method getOffset
+ * @param {Element} el an element
+ */
+export function getOffset(el) {
+  const box = el.getBoundingClientRect();
+
+  return {
+    top: box.top + window.pageYOffset - document.documentElement.clientTop,
+    left: box.left + window.pageXOffset - document.documentElement.clientLeft,
+  };
+}

package/.yalc/ember-sortable/app/modifiers/sortable-group.js

@@ -0,0 +1 @@
+export { default } from 'ember-sortable/modifiers/sortable-group';

package/.yalc/ember-sortable/app/modifiers/sortable-handle.js

@@ -0,0 +1 @@
+export { default } from 'ember-sortable/modifiers/sortable-handle';

package/.yalc/ember-sortable/app/modifiers/sortable-item.js

@@ -0,0 +1 @@
+export { default } from 'ember-sortable/modifiers/sortable-item';

package/.yalc/ember-sortable/app/services/ember-sortable-internal-state.js

@@ -0,0 +1 @@
+export { default } from 'ember-sortable/services/ember-sortable';

package/.yalc/ember-sortable/config/environment.js

@@ -0,0 +1,5 @@
+'use strict';
+
+module.exports = function (/* environment, appConfig */) {
+  return {};
+};

package/.yalc/ember-sortable/index.js

@@ -0,0 +1,5 @@
+'use strict';
+
+module.exports = {
+  name: require('./package').name,
+};

package/.yalc/ember-sortable/package.json

@@ -0,0 +1,65 @@
+{
+  "name": "ember-sortable",
+  "version": "4.0.3",
+  "description": "Sortable UI primitives for Ember.",
+  "keywords": [
+    "ember-addon",
+    "sortable"
+  ],
+  "repository": "https://github.com/adopted-ember-addons/ember-sortable",
+  "license": "MIT",
+  "author": "",
+  "directories": {
+    "doc": "doc",
+    "test": "tests"
+  },
+  "scripts": {
+    "build": "ember build",
+    "lint:hbs": "ember-template-lint .",
+    "lint:js": "eslint .",
+    "start": "ember serve",
+    "test:ember": "ember test",
+    "test:all": "ember try:each",
+    "lint": "yarn lint:hbs && yarn lint:js",
+    "release": "release-it"
+  },
+  "dependencies": {
+    "@ember/test-waiters": "^3.0.1",
+    "@embroider/macros": "^1.9.0",
+    "ember-cli-babel": "^7.26.11",
+    "ember-modifier": "^3.2.0"
+  },
+  "engines": {
+    "node": "14.* || >= 16"
+  },
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org"
+  },
+  "ember": {
+    "edition": "octane"
+  },
+  "ember-addon": {
+    "configPath": "tests/dummy/config",
+    "demoURL": "https://adopted-ember-addons.github.io/ember-sortable/demo/"
+  },
+  "release-it": {
+    "plugins": {
+      "release-it-lerna-changelog": {
+        "infile": "CHANGELOG.md",
+        "launchEditor": false
+      }
+    },
+    "git": {
+      "tagName": "v${version}"
+    },
+    "github": {
+      "release": true,
+      "tokenRef": "GITHUB_AUTH"
+    }
+  },
+  "volta": {
+    "node": "14.19.2",
+    "yarn": "1.22.18"
+  },
+  "yalcSig": "ab25b0d0909fb9a6a84df88f6bf1f2f5"
+}

package/.yalc/ember-sortable/yalc.sig

@@ -0,0 +1 @@
+ab25b0d0909fb9a6a84df88f6bf1f2f5

package/addon/components/fw-pagination-wrapper.js

@@ -414,7 +414,7 @@ export default Component.extend({
     },
 
     /**
-     * Query for settign a new sort order. Internal method.
+     * Query for setting a new sort order. Internal method.
      * @method querySort
      * @private
      * @param  {Number}  page      Page number to start
@@ -551,7 +551,7 @@ export default Component.extend({
                 page = max;
             }
 
-            // if we havve entries at the page number, use those
+            // if we have entries at the page number, use those
             // if missing, query them
             if (isNone(this.pageEntries.objectAt(page - 1))) {
                 this.incrementProperty('pagesSearching');

package/addon/components/fw-table-sortable.js

@@ -224,7 +224,18 @@ const TableSortable = Component.extend({
     sortOrder: computed('_defaultSort.[]', 'sortColumn', function() {
         let sortColumn = this.sortColumn;
         if (sortColumn) {
-            return [sortColumn].pushObjects(this._defaultSort);
+            // this addresses a bug where sorting by the default sort column would break
+            // in that case just sort by the selected column and ignore the default sort
+            if (this._defaultSort.any((sort) => {
+                return sort === sortColumn || sort === `${sortColumn}:desc` || `${sort}:desc` === sortColumn;
+            })) {
+                return [sortColumn];
+            }
+            // otherwise add the sort column to the front of the default sort array so the default sort is done after
+            let sortOrder = this._defaultSort.slice();
+            sortOrder.unshift(sortColumn);
+
+            return sortOrder;
         }
         return this._defaultSort;
     }),
@@ -239,7 +250,7 @@ const TableSortable = Component.extend({
     sortedData: sort('data', 'sortOrder'),
 
     /**
-     * Internal table instance, in general changes to the table should be done to columns or data so they update propery
+     * Internal table instance, in general changes to the table should be done to columns or data so they update properly
      *
      * @protected
      * @property table
@@ -375,7 +386,7 @@ const TableSortable = Component.extend({
             // determine how we are sorting
             let sortKey = column.sortKey || column.valuePath;
 
-            // if the column is now decending, sort decending
+            // if the column is now descending, sort descending
             if (!column.ascending) {
                 sortKey = `${sortKey}:desc`;
             }

package/addon/templates/components/fw-delete-modal.hbs

@@ -1,4 +1,4 @@
-<FwFullscreenModal @modal="confirm-choice" @size="xs" @model={{hash
+<FwFullscreenModal @modal="confirm-choice" @size="sm" @model={{hash
         confirmButtonText="Delete"
         confirmButtonStyle="danger"
         confirmButtonIcon="fa-regular fa-trash-can"