gristlabs_grist-core/app/client/ui/GridViewMenus.ts

import {allCommands} from 'app/client/components/commands';
import GridView from 'app/client/components/GridView';
import {makeT} from 'app/client/lib/localization';
import {ViewFieldRec} from 'app/client/models/entities/ViewFieldRec';
import {GristTooltips} from 'app/client/ui/GristTooltips';
import {withInfoTooltip} from 'app/client/ui/tooltips';
import {testId, theme, vars} from 'app/client/ui2018/cssVars';
import {icon} from 'app/client/ui2018/icons';
import {
  menuDivider,
  menuIcon,
  menuItem,
  menuItemCmd,
  menuItemSubmenu,
  menuItemTrimmed,
  menuSubHeader,
  menuSubHeaderMenu,
  menuText,
  searchableMenu,
  SearchableMenuItem,
} from 'app/client/ui2018/menus';
import {Sort} from 'app/common/SortSpec';
import {dom, DomElementArg, styled} from 'grainjs';
import {isListType, RecalcWhen} from "app/common/gristTypes";
import {ColumnRec} from "app/client/models/entities/ColumnRec";
import * as weasel from 'popweasel';
import isEqual = require('lodash/isEqual');

const t = makeT('GridViewMenus');

export function buildAddColumnMenu(gridView: GridView, index?: number) {
  const isSummaryTable = Boolean(gridView.viewSection.table().summarySourceTable());
  return [
    menuItem(
      async () => { await gridView.insertColumn(null, {index}); },
      menuIcon('Plus'),
      t("Add Column"),
      testId('new-columns-menu-add-new'),
    ),
    buildHiddenColumnsMenuItems(gridView, index),
    isSummaryTable ? null : [
      buildLookupSection(gridView, index),
      buildShortcutsMenuItems(gridView, index),
    ],
  ];
}

function buildHiddenColumnsMenuItems(gridView: GridView, index?: number) {
  const {viewSection} = gridView;
  const hiddenColumns = viewSection.hiddenColumns();
  if (hiddenColumns.length === 0) { return null; }

  if (hiddenColumns.length <= 5) {
    return [
      menuDivider(),
      menuSubHeader(t('Hidden Columns'), testId('new-columns-menu-hidden-columns-header')),
      hiddenColumns.map((col: ColumnRec) =>
        menuItem(
          async () => {
            await gridView.showColumn(col.id(), index);
          },
          col.label(),
          testId('new-columns-menu-hidden-column-inlined'),
        )
      ),
    ];
  } else {
    return [
      menuDivider(),
      menuSubHeaderMenu(
        () => {
          return searchableMenu(
            hiddenColumns.map((col) => ({
              cleanText: col.label().trim().toLowerCase(),
              builder: () => menuItemTrimmed(
                () => gridView.showColumn(col.id(), index),
                col.label(),
                testId('new-columns-menu-hidden-column-collapsed'),
              )
            })),
            {searchInputPlaceholder: t('Search columns')}
          );
        },
        {allowNothingSelected: true},
        t('Hidden Columns'),
        testId('new-columns-menu-hidden-columns-menu')
      ),
    ];
  }
}

function buildShortcutsMenuItems(gridView: GridView, index?: number) {
  return [
    menuDivider(),
    menuSubHeader(t("Shortcuts"), testId('new-columns-menu-shortcuts')),
    buildTimestampMenuItems(gridView, index),
    buildAuthorshipMenuItems(gridView, index),
    buildDetectDuplicatesMenuItems(gridView, index),
    buildUUIDMenuItem(gridView, index),
  ];
}

function buildTimestampMenuItems(gridView: GridView, index?: number) {
  return menuItemSubmenu(() => [
    menuItem(
      async () => {
        await gridView.insertColumn(t('Created At'), {
          colInfo: {
            label: t('Created At'),
            type: `DateTime:${gridView.gristDoc.docModel.docInfoRow.timezone()}`,
            isFormula: false,
            formula: 'NOW()',
            recalcWhen: RecalcWhen.DEFAULT,
            recalcDeps: null,
          },
          index,
          skipPopup: true,
        });
      },
      t("Apply to new records"),
      testId('new-columns-menu-shortcuts-timestamp-new'),
    ),
    menuItem(
      async () => {
        await gridView.insertColumn(t('Last Updated At'), {
          colInfo: {
            label: t('Last Updated At'),
            type: `DateTime:${gridView.gristDoc.docModel.docInfoRow.timezone()}`,
            isFormula: false,
            formula: 'NOW()',
            recalcWhen: RecalcWhen.MANUAL_UPDATES,
            recalcDeps: null,
          },
          index,
          skipPopup: true,
        });
      },
      t("Apply on record changes"),
      testId('new-columns-menu-shortcuts-timestamp-change'),
    ),
  ], {},
    t("Timestamp"),
    testId('new-columns-menu-shortcuts-timestamp')
  );
}

function buildAuthorshipMenuItems(gridView: GridView, index?: number) {
  return menuItemSubmenu(() => [
    menuItem(
      async () => {
        await gridView.insertColumn(t('Created By'), {
          colInfo: {
            label: t('Created By'),
            type: 'Text',
            isFormula: false,
            formula: 'user.Name',
            recalcWhen: RecalcWhen.DEFAULT,
            recalcDeps: null,
          },
          index,
          skipPopup: true,
        });
      },
      t("Apply to new records"),
      testId('new-columns-menu-shortcuts-author-new')
    ),
    menuItem(
      async () => {
        await gridView.insertColumn(t('Last Updated By'), {
          colInfo: {
            label: t('Last Updated By'),
            type: 'Text',
            isFormula: false,
            formula: 'user.Name',
            recalcWhen: RecalcWhen.MANUAL_UPDATES,
            recalcDeps: null,
          },
          index,
          skipPopup: true,
        });
      },
      t("Apply on record changes"),
      testId('new-columns-menu-shortcuts-author-change')
    ),
  ], {}, t("Authorship"), testId('new-columns-menu-shortcuts-author'));
}

function buildDetectDuplicatesMenuItems(gridView: GridView, index?: number) {
  const {viewSection} = gridView;
  return menuItemSubmenu(
    () => searchableMenu(
      viewSection.columns().map((col) => {
        function buildFormula() {
          if (isListType(col.type())) {
            return `any([len(${col.table().tableId()}.lookupRecords(${col.colId()}` +
              `=CONTAINS(x))) > 1 for x in $${col.colId()}])`;
          } else {
            return `$${col.colId()} != "" and $${col.colId()} is not None and ` +
              `len(${col.table().tableId()}.lookupRecords(` +
              `${col.colId()}=$${col.colId()})) > 1`;
          }
        }

        return {
          cleanText: col.label().trim().toLowerCase(),
          label: col.label(),
          action: async () => {
            await gridView.gristDoc.docData.bundleActions(t('Adding duplicates column'), async () => {
              const newColInfo = await gridView.insertColumn(
                t('Duplicate in {{- label}}', {label: col.label()}),
                {
                  colInfo: {
                    label: t('Duplicate in {{- label}}', {label: col.label()}),
                    type: 'Bool',
                    isFormula: true,
                    formula: buildFormula(),
                    recalcWhen: RecalcWhen.DEFAULT,
                    recalcDeps: null,
                    widgetOptions: JSON.stringify({
                      rulesOptions: [{
                        fillColor: '#ffc23d',
                        textColor: '#262633',
                      }],
                    }),
                  },
                  index,
                  skipPopup: true,
                }
              );

              // TODO: do the steps below as part of the AddColumn action.
              const newField = viewSection.viewFields().all()
                .find(field => field.colId() === newColInfo.colId);
              if (!newField) {
                throw new Error(`Unable to find field for column ${newColInfo.colId}`);
              }

              await newField.addEmptyRule();
              const newRule = newField.rulesCols()[0];
              if (!newRule) {
                throw new Error(`Unable to find conditional rule for field ${newField.label()}`);
              }

              await newRule.formula.setAndSave(`$${newColInfo.colId}`);
            }, {nestInActiveBundle: true});
          },
        };
      }),
      {searchInputPlaceholder: t('Search columns')}
    ),
    {allowNothingSelected: true},
    t('Detect Duplicates in...'),
    testId('new-columns-menu-shortcuts-duplicates'),
  );
}

function buildUUIDMenuItem(gridView: GridView, index?: number) {
  return menuItem(
    async () => {
      await gridView.gristDoc.docData.bundleActions(t('Adding UUID column'), async () => {
        // First create a formula column so that UUIDs are computed for existing cells.
        const {colRef} = await gridView.insertColumn(t('UUID'), {
          colInfo: {
            label: t('UUID'),
            type: 'Text',
            isFormula: true,
            formula: 'UUID()',
            recalcWhen: RecalcWhen.DEFAULT,
            recalcDeps: null,
          },
          index,
          skipPopup: true,
        });

        // Then convert it to a trigger formula, so that UUIDs aren't re-computed.
        //
        // TODO: remove this step and do it as part of the AddColumn action.
        await gridView.gristDoc.convertToTrigger(colRef, 'UUID()');
      }, {nestInActiveBundle: true});
    },
    withInfoTooltip(
      t('UUID'),
      GristTooltips.uuid(),
      {variant: 'hover'}
    ),
    testId('new-columns-menu-shortcuts-uuid'),
  );
}

function menuLabelWithBadge(label: string, toast: string) {
  return cssListLabel(
    cssListCol(label),
    cssListFun(toast));
}


function buildLookupSection(gridView: GridView, index?: number){
  function suggestAggregation(col: ColumnRec) {
    if (col.pureType() === 'Int' || col.pureType() === 'Numeric') {
      return [
        'sum', 'average', 'min', 'max',
      ];
    } else if (col.pureType() === 'Bool') {
      return [
        'count', 'percent'
      ];
    } else if (col.pureType() === 'Date' || col.pureType() === 'DateTime') {
      return [
        'list', 'min', 'max',
      ];
    } else {
      return [
        'list'
      ];
    }
  }
  //colTypeOverload allow to change created column type if default is wrong.
  function buildColumnInfo(
    fun: string,
    referenceToSource: string,
    col: ColumnRec) {
    function formula() {
      switch(fun) {
        case 'list': return `${referenceToSource}.${col.colId()}`;
        case 'average': return `AVERAGE(${referenceToSource}.${col.colId()})`;
        case 'min': return `MIN(${referenceToSource}.${col.colId()})`;
        case 'max': return `MAX(${referenceToSource}.${col.colId()})`;
        case 'count':
        case 'sum': return `SUM(${referenceToSource}.${col.colId()})`;
        case 'percent':
          return `AVERAGE(map(int, ${referenceToSource}.${col.colId()})) if ${referenceToSource} else None`;
        default: return `${referenceToSource}`;
      }
    }

    function type() {
      switch(fun) {
        case 'average': return 'Numeric';
        case 'min': return col.type();
        case 'max': return col.type();
        case 'count': return 'Int';
        case 'sum': return col.type();
        case 'percent': return 'Numeric';
        case 'list': return 'Any';
        default: return 'Any';
      }
    }

    function widgetOptions() {
      switch(fun) {
        case 'percent': return {numMode: 'percent'};
        default: return {};
      }
    }

    return {
      formula: formula(),
      type: type(),
      widgetOptions: JSON.stringify(widgetOptions()),
      isFormula: true,
    };
  }

  function buildLookupsMenuItems() {
    // Function that builds a menu for one of our Ref columns, we will show all columns
    // from the referenced table and offer to create a formula column with aggregation in case
    // our column is RefList.
    function buildRefColMenu(ref: ColumnRec, col: ColumnRec): SearchableMenuItem {
      // Helper for searching for this entry.
      const cleanText = col.label().trim().toLowerCase();

      // Next the label we will show.
      let label: string|HTMLElement;
      // For Ref column we will just show the column name.
      if (ref.pureType() === 'Ref') {
        label = col.label();
      } else {
        // For RefList column we will show the column name and the aggregation function which is the first
        // on of suggested action (and a default action).
        label = menuLabelWithBadge(col.label(), suggestAggregation(col)[0]);
      }

      return {
        cleanText,
        builder: buildItem
      };

      function buildItem() {
        if (ref.pureType() === 'Ref') {
          // Just insert a plain menu item that will insert a formula column with lookup.
          return menuItemTrimmed(
            () => insertPlainLookup(), col.label(),
            testId(`new-columns-menu-lookup-column`),
            testId(`new-columns-menu-lookup-column-${col.colId()}`),
          );
        } else {
          // Depending on the number of aggregation functions we will either create a plain menu item
          // or submenu with all the functions.
          const functions = suggestAggregation(col);
          if (functions.length === 1) {
            const action = () => insertAggLookup(functions[0]);
            return menuItem(action, label,
              testId(`new-columns-menu-lookup-column`),
              testId(`new-columns-menu-lookup-column-${col.colId()}`)
            );
          } else {
            return menuItemSubmenu(
              () => functions.map((fun) => menuItem(
                () => insertAggLookup(fun), fun,
                  testId(`new-columns-menu-lookup-submenu-function`),
                  testId(`new-columns-menu-lookup-submenu-function-${fun}`),
                )),
              {
                action: () => insertAggLookup(suggestAggregation(col)[0]),
              },
              label,
              testId(`new-columns-menu-lookup-submenu`),
              testId(`new-columns-menu-lookup-submenu-${col.colId()}`),
            );
          }
        }
      }

      function insertAggLookup(fun: string) {
        return gridView.insertColumn(`${ref.label()}_${col.label()}`, {
          colInfo: {
            label: `${ref.label()}_${col.label()}`,
            ...buildColumnInfo(
              fun,
              `$${ref.colId()}`,
              col,
            ),
            recalcDeps: null,
          },
          index,
          skipPopup: true,
        });
      }

      function insertPlainLookup() {
        return gridView.insertColumn(`${ref.label()}_${col.label()}`, {
          colInfo: {
            label: `${ref.label()}_${col.label()}`,
            isFormula: true,
            formula: `$${ref.colId()}.${col.colId()}`,
            recalcDeps: null,
            type: col.type(),
            widgetOptions: col.cleanWidgetOptionsJson()
          },
          index,
          skipPopup: true,
        });
      }
    }

    const {viewSection} = gridView;
    const columns = viewSection.columns();
    const onlyRefOrRefList = (c: ColumnRec) => c.pureType() === 'Ref' || c.pureType() === 'RefList';
    const references = columns.filter(onlyRefOrRefList);

    return references.map((ref) => menuItemSubmenu(
      () => searchableMenu(
        ref.refTable()?.visibleColumns().map(buildRefColMenu.bind(null, ref)) ?? [],
        {
          searchInputPlaceholder: t('Search columns')
        }
      ),
      {allowNothingSelected: true},
      `${ref.refTable()?.tableNameDef()} [${ref.label()}]`,
      testId(`new-columns-menu-lookup-${ref.colId()}`),
      testId(`new-columns-menu-lookup`),
    ));
  }

  interface RefTable {
    tableId: string,
    tableName: string,
    columns: ColumnRec[],
    referenceFields: ColumnRec[]
  }

  function buildReverseLookupsMenuItems() {

    const getReferencesToThisTable = (): RefTable[] => {
      const {viewSection} = gridView;
      const otherTables = gridView.gristDoc.docModel.allTables.all().filter((tab) =>
        tab.summarySourceTable() === 0 && tab.tableId.peek() !== viewSection.tableId());
      return otherTables.map((tab) => {
        return {
          tableId: tab.tableId(),
          tableName: tab.tableNameDef(),
          columns: tab.visibleColumns(),
          referenceFields:
            tab.visibleColumns.peek().filter((c) => (c.pureType() === 'Ref' || c.pureType() == 'RefList') &&
              c.refTable()?.tableId() === viewSection.tableId())
        };
      })
        .filter((tab) => tab.referenceFields.length > 0);
    };

    const insertColumn = async (tab: RefTable, col: ColumnRec, refCol: ColumnRec, aggregate: string) => {
      const formula =
        `${tab.tableId}.lookupRecords(${refCol.colId()}=${refCol.pureType() == 'RefList' ? 'CONTAINS($id)' : '$id'})`;
      await gridView.insertColumn(`${tab.tableId}_${col.label()}`, {
        colInfo: {
          label: `${tab.tableId}_${col.label()}`,
          ...buildColumnInfo(aggregate,
            formula,
            col)
        },
        index,
        skipPopup: true
      });
    };

    const tablesWithAnyRefColumn = getReferencesToThisTable();
    return tablesWithAnyRefColumn.map((tab: RefTable) => tab.referenceFields.map((refCol) => {
      const buildSubmenuForRevLookupMenuItem = (col: ColumnRec): SearchableMenuItem => {
        const aggregationList = suggestAggregation(col);
        const firstAggregation = aggregationList[0];
        if (!firstAggregation) {
          throw new Error(`No aggregation suggested for column ${col.label()}`);
        }
        return {
          cleanText: col.label().trim().toLowerCase(),
          builder: () => {
            const content = menuLabelWithBadge(col.label(), firstAggregation);
            // In case we have only one suggested column we will just insert it, and there is no,
            // need for submenu.
            if (aggregationList.length === 1) {
              const action = () => insertColumn(tab, col, refCol, firstAggregation);
              return menuItem(action, content, testId('new-columns-menu-revlookup-column'));
            } else {
              // We have some other suggested columns, we will build submenu for them.
              const submenu = () => {
                const items = aggregationList.map((fun) => {
                  const action = () => insertColumn(tab, col, refCol, fun);
                  return menuItem(action, fun, testId('new-columns-menu-revlookup-column-function'));
                });
                return items;
              };
              const options = {};
              return menuItemSubmenu(
                submenu,
                options,
                content,
                testId('new-columns-menu-revlookup-submenu'),
              );
            }
          }
        };
      };
      const label = `${tab.tableName} [← ${refCol.label()}]`;
      const options = {allowNothingSelected: true};
      const submenu = () => {
        const subItems = tab.columns.map(buildSubmenuForRevLookupMenuItem);
        return searchableMenu(subItems, {searchInputPlaceholder: t('Search columns')});
      };
      return menuItemSubmenu(submenu, options, label, testId('new-columns-menu-revlookup'));
    }));
  }

  const lookupMenu  = buildLookupsMenuItems();
  const reverseLookupMenu = buildReverseLookupsMenuItems();

  const menuContent = (lookupMenu.length === 0 && reverseLookupMenu.length === 0)
  ? [ menuText(
      t('No reference columns.'),
      testId('new-columns-menu-lookups-none'),
    )]
    : [lookupMenu, reverseLookupMenu];

  return [
    menuDivider(),
    menuSubHeader(
      withInfoTooltip(
        t('Lookups'),
        GristTooltips.lookups(),
        {variant: 'hover'}
      ),
      testId('new-columns-menu-lookups'),
    ),
    ...menuContent
    ];
}

export interface IMultiColumnContextMenu {
  // For multiple selection, true/false means the value applies to all columns, 'mixed' means it's
  // true for some columns, but not all.
  numColumns: number;
  numFrozen: number;
  disableModify: boolean|'mixed';  // If the columns are read-only. Mixed for multiple columns where some are read-only.
  isReadonly: boolean;
  isRaw: boolean;
  isFiltered: boolean;            // If this view shows a proper subset of all rows in the table.
  isFormula: boolean|'mixed';
  columnIndices: number[];
  totalColumnCount: number;
  disableFrozenMenu: boolean;
}

interface IColumnContextMenu extends IMultiColumnContextMenu {
  filterOpenFunc: () => void;
  sortSpec: Sort.SortSpec;
  colId: number;
}

export function calcFieldsCondition(fields: ViewFieldRec[], condition: (f: ViewFieldRec) => boolean): boolean|"mixed" {
  return fields.every(condition) ? true : (fields.some(condition) ? "mixed" : false);
}

export function buildColumnContextMenu(options: IColumnContextMenu) {
  const { disableModify, filterOpenFunc, colId, sortSpec, isReadonly } = options;

  const disableForReadonlyColumn = dom.cls('disabled', Boolean(disableModify) || isReadonly);

  const addToSortLabel = getAddToSortLabel(sortSpec, colId);

  return [
    menuItemCmd(allCommands.fieldTabOpen, t("Column Options")),
    menuItem(filterOpenFunc, t("Filter Data")),
    menuDivider({style: 'margin-bottom: 0;'}),
    cssRowMenuItem(
      customMenuItem(
        allCommands.sortAsc.run,
        dom('span', t("Sort"), {style: 'flex: 1  0 auto; margin-right: 8px;'},
            testId('sort-label')),
        icon('Sort', dom.style('transform', 'scaley(-1)')),
        'A-Z',
        dom.style('flex', ''),
        cssCustomMenuItem.cls('-selected', Sort.containsOnly(sortSpec, colId, Sort.ASC)),
        testId('sort-asc'),
      ),
      customMenuItem(
        allCommands.sortDesc.run,
        icon('Sort'),
        'Z-A',
        cssCustomMenuItem.cls('-selected', Sort.containsOnly(sortSpec, colId, Sort.DESC)),
        testId('sort-dsc'),
      ),
      testId('sort'),
    ),
    addToSortLabel ? [
      cssRowMenuItem(
        customMenuItem(
          allCommands.addSortAsc.run,
          cssRowMenuLabel(addToSortLabel, testId('add-to-sort-label')),
          icon('Sort', dom.style('transform', 'scaley(-1)')),
          'A-Z',
          cssCustomMenuItem.cls('-selected', Sort.contains(sortSpec, colId, Sort.ASC)),
          testId('add-to-sort-asc'),
        ),
        customMenuItem(
          allCommands.addSortDesc.run,
          icon('Sort'),
          'Z-A',
          cssCustomMenuItem.cls('-selected', Sort.contains(sortSpec, colId, Sort.DESC)),
          testId('add-to-sort-dsc'),
        ),
        testId('add-to-sort'),
      ),
    ] : null,
    menuDivider({style: 'margin-bottom: 0; margin-top: 0;'}),
    menuItem(allCommands.sortFilterTabOpen.run, t("More sort options ..."), testId('more-sort-options')),
    menuDivider({style: 'margin-top: 0;'}),
    menuItemCmd(allCommands.renameField, t("Rename column"), disableForReadonlyColumn),
    freezeMenuItemCmd(options),
    menuDivider(),
    buildMultiColumnMenu((options.disableFrozenMenu = true, options)),
    testId('column-menu'),
  ];
}

/**
 * Note about available options. There is a difference between clearing values (writing empty
 * string, which makes cells blank, including Numeric cells) and converting a column to an empty
 * column (i.e. column with empty formula; in this case a Numeric column becomes all 0s today).
 *
 * We offer both options if data columns are selected. If only formulas, only the second option
 * makes sense.
 */
export function buildMultiColumnMenu(options: IMultiColumnContextMenu) {
  const disableForReadonlyColumn = dom.cls('disabled', Boolean(options.disableModify) || options.isReadonly);
  const disableForReadonlyView = dom.cls('disabled', options.isReadonly);
  const num: number = options.numColumns;
  const nameClearColumns = options.isFiltered ?
    t('Reset {{count}} entire columns', {count: num}) :
    t('Reset {{count}} columns', {count: num});
  const nameDeleteColumns = t('Delete {{count}} columns', {count: num});
  const nameHideColumns = t('Hide {{count}} columns', {count: num});
  const frozenMenu = options.disableFrozenMenu ? null : freezeMenuItemCmd(options);
  return [
    frozenMenu ? [frozenMenu, menuDivider()]: null,
    // Offered only when selection includes formula columns, and converts only those.
    (options.isFormula ?
      menuItemCmd(allCommands.convertFormulasToData, t("Convert formula to data"),
        disableForReadonlyColumn) : null),

    // With data columns selected, offer an additional option to clear out selected cells.
    (options.isFormula !== true ?
      menuItemCmd(allCommands.clearValues, t("Clear values"), disableForReadonlyColumn) : null),

    (!options.isRaw ? menuItemCmd(allCommands.hideFields, nameHideColumns, disableForReadonlyView) : null),
    menuItemCmd(allCommands.clearColumns, nameClearColumns, disableForReadonlyColumn),
    menuItemCmd(allCommands.deleteFields, nameDeleteColumns, disableForReadonlyColumn),

    menuDivider(),
    menuItemCmd(allCommands.insertFieldBefore, t("Insert column to the left"), disableForReadonlyView),
    menuItemCmd(allCommands.insertFieldAfter, t("Insert column to the right"), disableForReadonlyView)
  ];
}

export function freezeAction(options: IMultiColumnContextMenu): { text: string; numFrozen: number; } | null {
 /**
   * When user clicks last column - don't offer freezing
   * When user clicks on a normal column - offer him to freeze all the columns to the
   * left (inclusive).
   * When user clicks on a frozen column - offer him to unfreeze all the columns to the
   * right (inclusive)
   * When user clicks on a set of columns then:
   * - If the set of columns contains the last columns that are frozen - offer unfreezing only those columns
   * - If the set of columns is right after the frozen columns or spans across - offer freezing only those columns
   *
   * All of the above are a single command - toggle freeze
   */

  const length = options.numColumns;

  // make some assertions - number of columns selected should always be > 0
  if (length === 0) { return null; }

  const indices = options.columnIndices;
  const firstColumnIndex = indices[0];
  const lastColumnIndex = indices[indices.length - 1];
  const numFrozen = options.numFrozen;

  // if set has last column in it - don't offer freezing
  if (lastColumnIndex == options.totalColumnCount - 1) {
    return null;
  }

  const isNormalColumn = length === 1 && (firstColumnIndex + 1) > numFrozen;
  const isFrozenColumn = length === 1 && (firstColumnIndex+ 1) <= numFrozen;
  const isSet = length > 1;
  const isLastFrozenSet = isSet && lastColumnIndex + 1 === numFrozen;
  const isFirstNormalSet = isSet && firstColumnIndex === numFrozen;
  const isSpanSet = isSet && firstColumnIndex <= numFrozen && lastColumnIndex >= numFrozen;

  let text = '';

  if (!isSet) {
    if (isNormalColumn) {
      // text to show depends on what user selected and how far are we from
      // last frozen column

      // if user clicked the first column or a column just after frozen set
      if (firstColumnIndex === 0 || firstColumnIndex === numFrozen) {
        text = t('Freeze {{count}} columns', {count: 1});
      } else {
        // else user clicked any other column that is farther, offer to freeze
        // proper number of column
        const properNumber = firstColumnIndex - numFrozen + 1;
        text = numFrozen ?
          t('Freeze {{count}} more columns', {count: properNumber}) :
          t('Freeze {{count}} columns', {count: properNumber});
      }
      return {
        text,
        numFrozen : firstColumnIndex + 1
      };
    } else if (isFrozenColumn) {
      // when user clicked last column in frozen set - offer to unfreeze this column
      if (firstColumnIndex + 1 === numFrozen) {
        text = t('Unfreeze {{count}} columns', {count: 1});
      } else {
        // else user clicked column that is not the last in a frozen set
        // offer to unfreeze proper number of columns
        const properNumber = numFrozen - firstColumnIndex;
        text = properNumber === numFrozen ?
          t('Unfreeze all columns') :
          t('Unfreeze {{count}} columns', {count: properNumber});
      }
      return {
        text,
        numFrozen : indices[0]
      };
    } else {
      return null;
    }
  } else {
    if (isLastFrozenSet) {
      text = t('Unfreeze {{count}} columns', {count: length});
      return {
        text,
        numFrozen : numFrozen - length
      };
    } else if (isFirstNormalSet) {
      text = t('Freeze {{count}} columns', {count: length});
      return {
        text,
        numFrozen : numFrozen + length
      };
    } else if (isSpanSet) {
      const toFreeze = lastColumnIndex + 1 - numFrozen;
      text = t('Freeze {{count}} more columns', {count: toFreeze});
      return {
        text,
        numFrozen : numFrozen + toFreeze
      };
    }  else {
      return null;
    }
  }
}

function freezeMenuItemCmd(options: IMultiColumnContextMenu) {
  // calculate action available for this options
  const toggle = freezeAction(options);
  // if we can't offer freezing - don't create a menu at all
  // this shouldn't happen - as current design offers some action on every column
  if (!toggle) { return null; }
  // create menu item if we have something to offer
  return menuItemCmd(allCommands.toggleFreeze, toggle.text);
}

// Returns 'Add to sort' is there are columns in the sort spec but colId is not part of it. Returns
// undefined if colId is the only column in the spec. Otherwise returns `Sorted (#N)` where #N is
// the position (1 based) of colId in the spec.
function getAddToSortLabel(sortSpec: Sort.SortSpec, colId: number): string|undefined {
  const columnsInSpec = sortSpec.map((n) =>Sort.getColRef(n));
  if (sortSpec.length !== 0 && !isEqual(columnsInSpec, [colId])) {
    const index = columnsInSpec.indexOf(colId);
    if (index > -1) {
      return t("Sorted (#{{count}})", {count: index + 1});
    } else {
      return t("Add to sort");
    }
  }
}

const cssRowMenuItem = styled((...args: DomElementArg[]) => dom('li', {tabindex: '-1'}, ...args), `
  display: flex;
  outline: none;
`);

const cssRowMenuLabel = styled('div', `
  margin-right: 8px;
  flex: 1 0 auto;
`);

const cssCustomMenuItem = styled('div', `
  padding: 8px 8px;
  display: flex;
  &:not(:hover) {
    background-color: ${theme.menuBg};
    color: ${theme.menuItemFg};
    --icon-color: ${theme.menuItemFg};
  }
  &:last-of-type {
    padding-right: 24px;
    flex: 0 0 auto;
  }
  &:first-of-type {
    padding-left: 24px;
    flex: 1 0 auto;
  }
  &-selected, &-selected:not(:hover) {
    background-color: ${theme.menuItemSelectedBg};
    color: ${theme.menuItemSelectedFg};
    --icon-color: ${theme.menuItemSelectedFg};
  }
`);

function customMenuItem(action: () => void, ...args: DomElementArg[]) {
  const element: HTMLElement = cssCustomMenuItem(
    ...args,
    dom.on('click', () => action()),
  );
  return element;
}

const cssListLabel = styled('div', `
  display: flex;
  justify-content: space-between;
  align-items: baseline;
  flex: 1;
`);

const cssListCol = styled('div', `
  flex: 1 0 auto;
`);

const cssListFun = styled('div', `
  flex: 0 0 auto;
  margin-left: 8px;
  text-transform: lowercase;
  padding: 1px 4px;
  border-radius: 3px;
  background-color: ${theme.choiceTokenBg};
  font-size: ${vars.xsmallFontSize};
  min-width: 28px;
  text-align: center;
  .${weasel.cssMenuItem.className}-sel & {
    color: ${theme.choiceTokenFg};
  }
`);