@fibery/views 1.1.2 → 1.1.5

package/README.md

@@ -0,0 +1,31 @@
+## How to update and publish @fibery/views
+
+Execute this:
+
+      cd fibery-views
+      yarn build
+      npm version patch
+      npm publish --dry-run
+
+Check the output, it should say there are at least 2 total files:
+
+      npm notice 📦  @fibery/views@1.1.4
+      npm notice === Tarball Contents ===
+      npm notice 37.1kB lib/views.js
+      npm notice 1.1kB  package.json
+      npm notice === Tarball Details ===
+      npm notice name:          @fibery/views
+      npm notice version:       1.1.4
+      npm notice package size:  4.7 kB
+      npm notice unpacked size: 38.3 kB
+      npm notice shasum:        0c8f17195d49cda1a321edc9a07d443c97ed6ba5
+      npm notice integrity:     sha512-XpaByuvN4YSZi[...]OFceXnL4J2VHw==
+      npm notice total files:   2
+      npm notice
+      + @fibery/views@1.1.4
+
+If everything looks good, do
+
+      npm publish
+
+Don't forget to commit the updated package.json.

package/lib/views.js

@@ -0,0 +1,1066 @@
+var utils = require('@fibery/expression-utils/utils');
+var immutableUpdate = require('immutability-helper');
+var _ = require('lodash');
+var visitors = require('@fibery/expression-utils/visitors');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var immutableUpdate__default = /*#__PURE__*/_interopDefaultLegacy(immutableUpdate);
+var ___default = /*#__PURE__*/_interopDefaultLegacy(_);
+
+function _extends() {
+  _extends = Object.assign || function (target) {
+    for (var i = 1; i < arguments.length; i++) {
+      var source = arguments[i];
+
+      for (var key in source) {
+        if (Object.prototype.hasOwnProperty.call(source, key)) {
+          target[key] = source[key];
+        }
+      }
+    }
+
+    return target;
+  };
+
+  return _extends.apply(this, arguments);
+}
+
+const getFieldType = (schema, fromType, field) => {
+  if (!schema.typeObjectsByName.hasOwnProperty(fromType) || !schema.typeObjectsByName[fromType].fieldObjectsByName.hasOwnProperty(field)) {
+    return null;
+  }
+
+  return schema.typeObjectsByName[fromType].fieldObjectsByName[field].type;
+};
+
+const getFieldMeta = (schema, fromType, field) => {
+  if (!schema.typeObjectsByName.hasOwnProperty(fromType) || !schema.typeObjectsByName[fromType].fieldObjectsByName.hasOwnProperty(field)) {
+    return null;
+  }
+
+  return schema.typeObjectsByName[fromType].fieldObjectsByName[field].rawMeta;
+};
+
+const getUnitTypeForTextField = fieldMeta => {
+  switch (fieldMeta["ui/type"]) {
+    case "email":
+      return "email";
+
+    case "url":
+      return "url";
+
+    case "phone":
+      return "phone";
+
+    default:
+      return "text";
+  }
+};
+
+const fixViewUnit = (schema, fromType, unit) => {
+  const {
+    type,
+    expression
+  } = unit;
+
+  if (type === "date") {
+    const [field] = expression;
+
+    if (getFieldType(schema, fromType, field) === "fibery/date-time") {
+      return _extends({}, unit, {
+        type: "date-time"
+      });
+    }
+  }
+
+  if (type === "date-range") {
+    const [field] = expression;
+
+    if (getFieldType(schema, fromType, field) === "fibery/date-time-range") {
+      return _extends({}, unit, {
+        type: "date-time-range"
+      });
+    }
+  }
+
+  if (type === "text") {
+    const [field] = expression;
+    const fieldType = getFieldType(schema, fromType, field);
+
+    if (fieldType === "fibery/email") {
+      return _extends({}, unit, {
+        type: "email"
+      });
+    }
+  }
+
+  if (["text", "email", "phone", "url"].includes(type)) {
+    const [field] = expression;
+
+    if (getFieldType(schema, fromType, field) === "fibery/text") {
+      return _extends({}, unit, {
+        type: getUnitTypeForTextField(getFieldMeta(schema, fromType, field))
+      });
+    }
+  }
+
+  return unit;
+};
+
+const deleteExpressionWithNotFoundFieldsOrTypesInQueryExpression = (schema, queryExpression) => {
+  const {
+    "q/from": fromExpression,
+    "q/where": whereExpression,
+    "q/order-by": orderByExpression
+  } = queryExpression;
+
+  if (schema.typeObjectsByName.hasOwnProperty(fromExpression)) {
+    const typeObject = schema.typeObjectsByName[fromExpression];
+    return ___default["default"].pickBy(_extends({}, queryExpression, whereExpression ? {
+      "q/where": visitors.deleteExpressionsWithNotFoundFieldsVisitor(typeObject).visitExpression(whereExpression)
+    } : null, orderByExpression ? {
+      "q/order-by": visitors.deleteExpressionsWithNotFoundFieldsVisitor(typeObject).visitOrderByExpression(orderByExpression)
+    } : null));
+  }
+
+  return null;
+};
+const replaceNamesWithIdsInExpression = (schema, fromType, expression) => {
+  if (schema.typeObjectsByName.hasOwnProperty(fromType)) {
+    const typeObject = schema.typeObjectsByName[fromType];
+    return visitors.replaceNamesWithIdsVisitor(typeObject).visitExpression(expression);
+  }
+
+  return expression;
+};
+const replaceIdsWithNamesInExpression = (schema, fromTypeId, expression) => {
+  if (schema.typeObjectsById.hasOwnProperty(fromTypeId)) {
+    const typeObject = schema.typeObjectsById[fromTypeId];
+    return visitors.replaceIdsWithNamesVisitor(typeObject).visitExpression(expression);
+  }
+
+  return expression;
+};
+const visitViewUnit = (fromType, unit, visitor) => {
+  const {
+    expression
+  } = unit;
+
+  if (expression) {
+    return _extends({}, unit, {
+      expression: visitor.visitExpression(fromType, expression)
+    });
+  }
+
+  return unit;
+};
+const replaceIdsWithNamesInQueryExpression = (schema, queryExpression) => {
+  const {
+    "q/from": fromExpression,
+    "q/where": whereExpression,
+    "q/order-by": orderByExpression
+  } = queryExpression;
+
+  if (schema.typeObjectsById.hasOwnProperty(fromExpression)) {
+    const typeObject = schema.typeObjectsById[fromExpression];
+    return _extends({}, queryExpression, {
+      "q/from": typeObject.name
+    }, whereExpression ? {
+      "q/where": visitors.replaceIdsWithNamesVisitor(typeObject).visitExpression(whereExpression)
+    } : null, orderByExpression ? {
+      "q/order-by": visitors.replaceIdsWithNamesVisitor(typeObject).visitOrderByExpression(orderByExpression)
+    } : null);
+  }
+
+  return queryExpression;
+};
+const replaceNamesWithIdsInQueryExpression = (schema, queryExpression) => {
+  const {
+    "q/from": fromExpression,
+    "q/where": whereExpression,
+    "q/order-by": orderByExpression
+  } = queryExpression;
+
+  if (schema.typeObjectsByName.hasOwnProperty(fromExpression)) {
+    const typeObject = schema.typeObjectsByName[fromExpression];
+    return _extends({}, queryExpression, {
+      "q/from": typeObject.id
+    }, whereExpression ? {
+      "q/where": visitors.replaceNamesWithIdsVisitor(typeObject).visitExpression(whereExpression)
+    } : null, orderByExpression ? {
+      "q/order-by": visitors.replaceNamesWithIdsVisitor(typeObject).visitOrderByExpression(orderByExpression)
+    } : null);
+  }
+
+  return queryExpression;
+};
+const deleteExpressionWithNotFoundFieldsOrTypesInExpression = (schema, fromType, expression) => {
+  if (schema.typeObjectsByName.hasOwnProperty(fromType)) {
+    const typeObject = schema.typeObjectsByName[fromType];
+    return visitors.deleteExpressionsWithNotFoundFieldsVisitor(typeObject).visitExpression(expression);
+  }
+
+  return null;
+};
+const isUnitExpressionValid = unit => {
+  if (unit.hasOwnProperty("expression")) {
+    const {
+      expression
+    } = unit;
+    return expression !== null;
+  }
+
+  return true;
+};
+
+const visitQueryExpressionHolder = (queryHolder, visitor) => {
+  if (queryHolder) {
+    const {
+      query
+    } = queryHolder;
+
+    if (query) {
+      const queryNew = visitor.visitQueryExpression(query);
+      return queryNew ? _extends({}, queryHolder, {
+        query: queryNew
+      }) : null;
+    }
+
+    return queryHolder;
+  }
+
+  return queryHolder;
+};
+
+const visitAxisUnits = (axis, fromType, visitor) => {
+  return fromType ? immutableUpdate__default["default"](axis, {
+    contextExpression: {
+      $apply: contextExpression => contextExpression ? visitor.visitExpression(fromType, contextExpression) : contextExpression
+    },
+    units: {
+      $apply: units => units ? units.map(unit => visitViewUnit(fromType, unit, visitor)).filter(unit => isUnitExpressionValid(unit)).map(unit => visitor.visitViewUnit ? visitor.visitViewUnit(fromType, unit) : unit) : undefined
+    }
+  }) : axis;
+};
+
+const visitAxis$1 = (axis, visitor) => {
+  if (axis && axis.hasOwnProperty("query")) {
+    const fromType = ___default["default"].get(axis, ["query", "q/from"]);
+
+    const axisWithVisitedQuery = visitQueryExpressionHolder(axis, visitor);
+
+    if (axisWithVisitedQuery) {
+      return visitAxisUnits(axisWithVisitedQuery, fromType, visitor);
+    }
+
+    return axisWithVisitedQuery;
+  }
+
+  if (axis && axis.hasOwnProperty("enums")) {
+    const axisNew = immutableUpdate__default["default"](axis, {
+      enums: {
+        $apply: enums => visitor.visitEnums(enums)
+      }
+    });
+    const {
+      enums
+    } = axisNew;
+    return enums ? axisNew : null;
+  }
+
+  return axis;
+};
+
+const ensureAxisAndItemExpressionInvariant$1 = view => {
+  const actions = [];
+
+  const x = ___default["default"].get(view, ["fibery/meta", "x"]);
+
+  const y = ___default["default"].get(view, ["fibery/meta", "y"]);
+
+  const items = ___default["default"].get(view, ["fibery/meta", "items"]);
+
+  if (x === null) {
+    const resetActions = items.map(item => () => item.xExpression = null);
+    actions.push(...resetActions);
+  }
+
+  if (x !== null && ___default["default"].some(items, ({
+    xExpression
+  }) => xExpression === null)) {
+    const resetActions = items.map(item => () => item.xExpression = null);
+    actions.push(...resetActions);
+    actions.push(() => ___default["default"].set(view, ["fibery/meta", "x"], null));
+  }
+
+  if (y === null) {
+    const resetActions = items.map(item => () => item.yExpression = null);
+    actions.push(...resetActions);
+  }
+
+  if (y !== null && ___default["default"].some(items, ({
+    yExpression
+  }) => yExpression === null)) {
+    const resetActions = items.map(item => () => item.yExpression = null);
+    actions.push(...resetActions);
+    actions.push(() => ___default["default"].set(view, ["fibery/meta", "y"], null));
+  }
+
+  if (x !== null && ___default["default"].isEmpty(items)) {
+    actions.push(() => ___default["default"].set(view, ["fibery/meta", "x"], null));
+  }
+
+  if (y !== null && ___default["default"].isEmpty(items)) {
+    actions.push(() => ___default["default"].set(view, ["fibery/meta", "y"], null));
+  }
+
+  if (x !== null && ___default["default"].some(items, ({
+    xExpression
+  }) => !utils.isAxisFieldExpression(xExpression))) {
+    const resetActions = items.map(item => () => item.xExpression = null);
+    actions.push(...resetActions);
+    actions.push(() => ___default["default"].set(view, ["fibery/meta", "x"], null));
+  }
+
+  if (y !== null && ___default["default"].some(items, ({
+    yExpression
+  }) => !utils.isAxisFieldExpression(yExpression))) {
+    const resetActions = items.map(item => () => item.yExpression = null);
+    actions.push(...resetActions);
+    actions.push(() => ___default["default"].set(view, ["fibery/meta", "y"], null));
+  }
+
+  actions.forEach(action => action());
+  return view;
+};
+
+const visitView$4 = (view, visitor) => immutableUpdate__default["default"](view, {
+  "fibery/meta": {
+    x: {
+      $apply: x => visitAxis$1(x, visitor)
+    },
+    y: {
+      $apply: y => visitAxis$1(y, visitor)
+    },
+    items: {
+      $apply: items => items.map(item => {
+        const fromType = ___default["default"].get(item, ["query", "q/from"]);
+
+        return fromType ? immutableUpdate__default["default"](item, {
+          xExpression: {
+            $apply: xExpression => xExpression ? visitor.visitExpression(fromType, xExpression) : xExpression
+          },
+          yExpression: {
+            $apply: yExpression => yExpression ? visitor.visitExpression(fromType, yExpression) : yExpression
+          },
+          contextExpression: {
+            $apply: contextExpression => contextExpression ? visitor.visitExpression(fromType, contextExpression) : contextExpression
+          },
+          query: {
+            $apply: query => query ? visitor.visitQueryExpression(query) : null
+          },
+          units: {
+            $apply: units => units ? units.map(unit => visitViewUnit(fromType, unit, visitor)).filter(unit => isUnitExpressionValid(unit)).map(unit => visitor.visitViewUnit ? visitor.visitViewUnit(fromType, unit) : unit) : undefined
+          },
+          colorCoding: {
+            $apply: colorCodings => {
+              return colorCodings ? colorCodings.map(colorCoding => _extends({}, colorCoding, {
+                expression: visitor.visitExpression(fromType, colorCoding.expression)
+              })).filter(colorCoding => colorCoding.expression !== null) : undefined;
+            }
+          }
+        }) : item;
+      }).filter(item => {
+        const {
+          query
+        } = item;
+        return query ? item : null;
+      })
+    }
+  }
+});
+
+const replaceNamesWithIdsViewVisitor = schema => {
+  const visitor = {
+    visitQueryExpression: queryExpression => replaceNamesWithIdsInQueryExpression(schema, queryExpression),
+    visitExpression: (fromType, expression) => replaceNamesWithIdsInExpression(schema, fromType, expression),
+    visitEnums: enums => ___default["default"].entries(enums).reduce((result, [type, queryHolder]) => {
+      if (schema.typeObjectsByName.hasOwnProperty(type)) {
+        const typeObject = schema.typeObjectsByName[type];
+
+        const fromType = ___default["default"].get(queryHolder, ["query", "q/from"]);
+
+        const axisWithVisitedQuery = visitQueryExpressionHolder(queryHolder, visitor);
+        result[typeObject.id] = visitAxisUnits(axisWithVisitedQuery, fromType, visitor);
+      } else {
+        result[type] = queryHolder;
+      }
+
+      return result;
+    }, {})
+  };
+  return visitor;
+};
+
+const replaceIdsWithNamesViewVisitor = schema => {
+  const visitor = {
+    visitQueryExpression: queryExpression => replaceIdsWithNamesInQueryExpression(schema, queryExpression),
+    visitExpression: (fromType, expression) => replaceIdsWithNamesInExpression(schema, fromType, expression),
+    visitEnums: enums => ___default["default"].entries(enums).reduce((result, [typeId, queryHolder]) => {
+      if (schema.typeObjectsById.hasOwnProperty(typeId)) {
+        const typeObject = schema.typeObjectsById[typeId];
+
+        const fromType = ___default["default"].get(queryHolder, ["query", "q/from"]);
+
+        const axisWithVisitedQuery = visitQueryExpressionHolder(queryHolder, visitor);
+        result[typeObject.name] = visitAxisUnits(axisWithVisitedQuery, fromType, visitor);
+      } else {
+        result[typeId] = queryHolder;
+      }
+
+      return result;
+    }, {})
+  };
+  return visitor;
+};
+
+const deleteExpressionWithNotFoundFieldsOrTypesViewVisitor = schema => {
+  const visitor = {
+    visitQueryExpression: queryExpression => deleteExpressionWithNotFoundFieldsOrTypesInQueryExpression(schema, queryExpression),
+    visitExpression: (fromType, expression) => deleteExpressionWithNotFoundFieldsOrTypesInExpression(schema, fromType, expression),
+    visitEnums: enums => {
+      const enumsNew = ___default["default"].entries(enums).reduce((result, [type, queryHolder]) => {
+        if (schema.typeObjectsByName.hasOwnProperty(type)) {
+          const typeObject = schema.typeObjectsByName[type];
+          const queryHolderResult = visitQueryExpressionHolder(queryHolder, visitor);
+
+          if (queryHolderResult) {
+            result[typeObject.name] = queryHolderResult;
+          }
+
+          return result;
+        }
+
+        return result;
+      }, {});
+
+      return ___default["default"].isEmpty(enumsNew) ? null : enumsNew;
+    }
+  };
+  return visitor;
+};
+
+const fixUserSelectedUnitsViewVisitor = schema => {
+  return {
+    visitQueryExpression: queryExpression => queryExpression,
+    visitExpression: (fromType, expression) => expression,
+    visitEnums: enums => enums,
+    visitViewUnit: (fromType, unit) => fixViewUnit(schema, fromType, unit)
+  };
+};
+
+const replaceIdsWithNamesInBoardView = (schema, view) => visitView$4(view, replaceIdsWithNamesViewVisitor(schema));
+const replaceNamesWithIdsInBoardView = (schema, view) => visitView$4(view, replaceNamesWithIdsViewVisitor(schema));
+const deleteExpressionWithNotFoundOrInvalidFieldsOrTypesInBoardView = (schema, view, ensureAxisInvariant = true) => {
+  const viewNew = visitView$4(view, deleteExpressionWithNotFoundFieldsOrTypesViewVisitor(schema));
+  return ensureAxisInvariant ? ensureAxisAndItemExpressionInvariant$1(viewNew) : viewNew;
+};
+const fixUserSelectedUnitsInBoardView = (schema, view) => {
+  return visitView$4(view, fixUserSelectedUnitsViewVisitor(schema));
+};
+
+const visitView$3 = (view, visitor) => immutableUpdate__default["default"](view, {
+  "fibery/meta": {
+    items: {
+      $apply: items => items.map(item => {
+        const fromType = ___default["default"].get(item, ["query", "q/from"]);
+
+        return fromType ? immutableUpdate__default["default"](item, {
+          startExpression: {
+            $apply: startExpression => startExpression ? visitor.visitExpression(fromType, startExpression) : startExpression
+          },
+          endExpression: {
+            $apply: endExpression => endExpression ? visitor.visitExpression(fromType, endExpression) : endExpression
+          },
+          contextExpression: {
+            $apply: contextExpression => contextExpression ? visitor.visitExpression(fromType, contextExpression) : contextExpression
+          },
+          query: {
+            $apply: query => query ? visitor.visitQueryExpression(query) : null
+          },
+          units: {
+            $apply: units => units ? units.map(unit => visitViewUnit(fromType, unit, visitor)).filter(unit => isUnitExpressionValid(unit)).map(unit => visitor.visitViewUnit ? visitor.visitViewUnit(fromType, unit) : unit) : undefined
+          },
+          colorCoding: {
+            $apply: colorCodings => {
+              return colorCodings && colorCodings.map(colorCoding => _extends({}, colorCoding, {
+                expression: visitor.visitExpression(fromType, colorCoding.expression)
+              })).filter(colorCoding => colorCoding.expression !== null);
+            }
+          }
+        }) : item;
+      }).filter(item => {
+        const {
+          query
+        } = item;
+        return query ? item : null;
+      })
+    }
+  }
+});
+
+const replaceNamesWithIdsInCalendarView = (schema, view) => {
+  return visitView$3(view, {
+    visitExpression: (fromType, expression) => replaceNamesWithIdsInExpression(schema, fromType, expression),
+    visitQueryExpression: query => replaceNamesWithIdsInQueryExpression(schema, query)
+  });
+};
+const replaceIdsWithNamesInCalendarView = (schema, view) => {
+  return visitView$3(view, {
+    visitExpression: (fromType, expression) => replaceIdsWithNamesInExpression(schema, fromType, expression),
+    visitQueryExpression: query => replaceIdsWithNamesInQueryExpression(schema, query)
+  });
+};
+const deleteExpressionWithNotFoundFieldsOrTypesInCalendarView = (schema, view) => visitView$3(view, {
+  visitQueryExpression: queryExpression => deleteExpressionWithNotFoundFieldsOrTypesInQueryExpression(schema, queryExpression),
+  visitExpression: (fromType, expression) => deleteExpressionWithNotFoundFieldsOrTypesInExpression(schema, fromType, expression)
+});
+const fixUserSelectedUnitsInCalendarView = (schema, view) => {
+  return visitView$3(view, {
+    visitExpression: (fromType, expression) => expression,
+    visitQueryExpression: query => query,
+    visitViewUnit: (fromType, unit) => fixViewUnit(schema, fromType, unit)
+  });
+};
+
+const visitView$2 = (view, visitor) => immutableUpdate__default["default"](view, {
+  "fibery/meta": {
+    items: {
+      $apply: items => items.map(item => {
+        const fromType = ___default["default"].get(item, ["query", "q/from"]);
+
+        return fromType ? immutableUpdate__default["default"](item, {
+          postExpression: {
+            $apply: postExpression => postExpression ? visitor.visitExpression(fromType, postExpression) : postExpression
+          },
+          contextExpression: {
+            $apply: contextExpression => contextExpression ? visitor.visitExpression(fromType, contextExpression) : contextExpression
+          },
+          query: {
+            $apply: query => query ? visitor.visitQueryExpression(query) : null
+          },
+          units: {
+            $apply: units => units ? units.map(unit => visitViewUnit(fromType, unit, visitor)).filter(unit => isUnitExpressionValid(unit)).map(unit => visitor.visitViewUnit ? visitor.visitViewUnit(fromType, unit) : unit) : undefined
+          },
+          colorCoding: {
+            $apply: colorCodings => {
+              return colorCodings && colorCodings.map(colorCoding => _extends({}, colorCoding, {
+                expression: visitor.visitExpression(fromType, colorCoding.expression)
+              })).filter(colorCoding => colorCoding.expression !== null);
+            }
+          }
+        }) : item;
+      }).filter(item => {
+        const {
+          query
+        } = item;
+        return query ? item : null;
+      })
+    }
+  }
+});
+
+const replaceNamesWithIdsInFeedView = (schema, view) => {
+  return visitView$2(view, {
+    visitExpression: (fromType, expression) => replaceNamesWithIdsInExpression(schema, fromType, expression),
+    visitQueryExpression: query => replaceNamesWithIdsInQueryExpression(schema, query)
+  });
+};
+const replaceIdsWithNamesInFeedView = (schema, view) => {
+  return visitView$2(view, {
+    visitExpression: (fromType, expression) => replaceIdsWithNamesInExpression(schema, fromType, expression),
+    visitQueryExpression: query => replaceIdsWithNamesInQueryExpression(schema, query)
+  });
+};
+const deleteExpressionWithNotFoundFieldsOrTypesInFeedView = (schema, view) => visitView$2(view, {
+  visitQueryExpression: queryExpression => deleteExpressionWithNotFoundFieldsOrTypesInQueryExpression(schema, queryExpression),
+  visitExpression: (fromType, expression) => deleteExpressionWithNotFoundFieldsOrTypesInExpression(schema, fromType, expression)
+});
+const fixUserSelectedUnitsInFeedView = (schema, view) => {
+  return visitView$2(view, {
+    visitExpression: (fromType, expression) => expression,
+    visitQueryExpression: query => query,
+    visitViewUnit: (fromType, unit) => fixViewUnit(schema, fromType, unit)
+  });
+};
+
+const visitSmartFolder = (smartFolder, visitor) => immutableUpdate__default["default"](smartFolder, {
+  "fibery/meta": {
+    items: {
+      $apply: items => {
+        const isOldSmartFolder = !items.every(item => item.hasOwnProperty("groupBy"));
+        const removedItemsIndexes = items.map((item, index) => visitor.visitQueryExpression(item.query) ? null : index).filter(value => value !== null);
+        return items.map((item, index) => {
+          if (isOldSmartFolder) {
+            return item;
+          }
+
+          const fromType = ___default["default"].get(item, ["query", "q/from"]);
+
+          return fromType ? immutableUpdate__default["default"](item, {
+            groupBy: {
+              $apply: groupBy => {
+                const removedItemsBeforeCurrent = removedItemsIndexes.filter(n => n < index);
+                return groupBy ? visitor.visitGroupByExpression(groupBy, fromType, removedItemsBeforeCurrent.length) : null;
+              }
+            }
+          }) : item;
+        }).map(item => {
+          const fromType = ___default["default"].get(item, ["query", "q/from"]);
+
+          return fromType ? immutableUpdate__default["default"](item, {
+            query: {
+              $apply: query => {
+                const visitedQuery = visitor.visitQueryExpression(query);
+                return query ? visitedQuery : null;
+              }
+            },
+            units: {
+              $apply: units => units ? units.map(unit => visitViewUnit(fromType, unit, visitor)).filter(unit => isUnitExpressionValid(unit)).map(unit => visitor.visitViewUnit ? visitor.visitViewUnit(fromType, unit) : unit) : undefined
+            },
+            contextExpression: {
+              $apply: contextExpression => contextExpression ? visitor.visitExpression(fromType, contextExpression) : contextExpression
+            },
+            colorCoding: {
+              $apply: colorCodings => {
+                return colorCodings ? colorCodings.map(colorCoding => _extends({}, colorCoding, {
+                  expression: visitor.visitExpression(fromType, colorCoding.expression)
+                })).filter(colorCoding => colorCoding.expression !== null) : undefined;
+              }
+            }
+          }) : item;
+        }).filter(item => {
+          const {
+            query
+          } = item;
+          return query ? item : null;
+        });
+      }
+    }
+  }
+});
+
+const deleteExpressionWithNotFoundFieldsOrTypesInGroupByExpression = (schema, groupByExpression, fromType, removedItems) => {
+  if (!groupByExpression) {
+    return null;
+  }
+
+  const [[index, {
+    expression
+  }]] = Object.entries(groupByExpression);
+  const visitedExpression = deleteExpressionWithNotFoundFieldsOrTypesInExpression(schema, fromType, expression);
+
+  if (visitedExpression) {
+    return {
+      [`${parseInt(index) - removedItems}`]: {
+        expression: visitedExpression
+      }
+    };
+  }
+
+  return null;
+};
+
+const replaceIdsWithNamesInGroupByExpression = (schema, groupByExpression, fromType) => {
+  if (!groupByExpression) {
+    return null;
+  }
+
+  const [[index, {
+    expression
+  }]] = Object.entries(groupByExpression);
+
+  if (schema.typeObjectsById.hasOwnProperty(fromType)) {
+    const typeObject = schema.typeObjectsById[fromType];
+    return {
+      [index]: {
+        expression: visitors.replaceIdsWithNamesVisitor(typeObject).visitExpression(expression)
+      }
+    };
+  }
+
+  return null;
+};
+const replaceNamesWithIdsInGroupByExpression = (schema, groupByExpression, fromType) => {
+  if (!groupByExpression) {
+    return null;
+  }
+
+  const [[index, {
+    expression
+  }]] = Object.entries(groupByExpression);
+
+  if (schema.typeObjectsByName.hasOwnProperty(fromType)) {
+    const typeObject = schema.typeObjectsByName[fromType];
+    return {
+      [index]: {
+        expression: visitors.replaceNamesWithIdsVisitor(typeObject).visitExpression(expression)
+      }
+    };
+  }
+
+  return null;
+};
+const replaceNamesWithIdsInSmartFolder = (schema, smartFolder) => visitSmartFolder(smartFolder, {
+  visitQueryExpression: query => replaceNamesWithIdsInQueryExpression(schema, query),
+  visitGroupByExpression: (groupBy, fromType) => replaceNamesWithIdsInGroupByExpression(schema, groupBy, fromType),
+  visitExpression: (fromType, expression) => replaceNamesWithIdsInExpression(schema, fromType, expression)
+});
+const replaceIdsWithNamesInSmartFolder = (schema, smartFolder) => visitSmartFolder(smartFolder, {
+  visitQueryExpression: query => replaceIdsWithNamesInQueryExpression(schema, query),
+  visitGroupByExpression: (groupBy, fromType) => replaceIdsWithNamesInGroupByExpression(schema, groupBy, fromType),
+  visitExpression: (fromType, expression) => replaceIdsWithNamesInExpression(schema, fromType, expression)
+});
+const deleteExpressionWithNotFoundFieldsOrTypesInSmartFolder = (schema, smartFolder) => visitSmartFolder(smartFolder, {
+  visitQueryExpression: query => deleteExpressionWithNotFoundFieldsOrTypesInQueryExpression(schema, query),
+  visitGroupByExpression: (groupBy, fromType, removedItems) => deleteExpressionWithNotFoundFieldsOrTypesInGroupByExpression(schema, groupBy, fromType, removedItems),
+  visitExpression: (fromType, expression) => deleteExpressionWithNotFoundFieldsOrTypesInExpression(schema, fromType, expression)
+});
+const fixUserSelectedUnitsInSmartFolder = (schema, view) => {
+  return visitSmartFolder(view, {
+    visitQueryExpression: query => query,
+    visitGroupByExpression: groupBy => groupBy,
+    visitExpression: (fromType, expression) => expression,
+    visitViewUnit: (fromType, unit) => fixViewUnit(schema, fromType, unit)
+  });
+};
+
+const visitView$1 = (view, visitor) => immutableUpdate__default["default"](view, {
+  "fibery/meta": {
+    items: {
+      $apply: items => items.map(item => {
+        const fromType = ___default["default"].get(item, ["query", "q/from"]);
+
+        return fromType ? immutableUpdate__default["default"](item, {
+          query: {
+            $apply: query => query ? visitor.visitQueryExpression(query) : null
+          },
+          contextExpression: {
+            $apply: contextExpression => contextExpression ? visitor.visitExpression(fromType, contextExpression) : contextExpression
+          },
+          units: {
+            $apply: units => units ? units.map(unit => visitViewUnit(fromType, unit, visitor)).filter(unit => isUnitExpressionValid(unit)).map(unit => visitor.visitViewUnit ? visitor.visitViewUnit(fromType, unit) : unit) : undefined
+          },
+          colorCoding: {
+            $apply: colorCodings => {
+              return colorCodings && colorCodings.map(colorCoding => _extends({}, colorCoding, {
+                expression: visitor.visitExpression(fromType, colorCoding.expression)
+              })).filter(colorCoding => colorCoding.expression !== null);
+            }
+          }
+        }) : item;
+      }).filter(item => {
+        const {
+          query
+        } = item;
+        return query ? item : null;
+      })
+    }
+  }
+});
+
+const replaceNamesWithIdsInTableView = (schema, view) => visitView$1(view, {
+  visitExpression: (fromType, expression) => replaceNamesWithIdsInExpression(schema, fromType, expression),
+  visitQueryExpression: query => replaceNamesWithIdsInQueryExpression(schema, query)
+});
+const replaceIdsWithNamesInTableView = (schema, view) => visitView$1(view, {
+  visitExpression: (fromType, expression) => replaceIdsWithNamesInExpression(schema, fromType, expression),
+  visitQueryExpression: query => replaceIdsWithNamesInQueryExpression(schema, query)
+});
+const deleteExpressionWithNotFoundFieldsOrTypesInTableView = (schema, view) => visitView$1(view, {
+  visitQueryExpression: queryExpression => deleteExpressionWithNotFoundFieldsOrTypesInQueryExpression(schema, queryExpression),
+  visitExpression: (fromType, expression) => deleteExpressionWithNotFoundFieldsOrTypesInExpression(schema, fromType, expression)
+});
+const fixUserSelectedUnitsInTableView = (schema, view) => visitView$1(view, {
+  visitExpression: (fromType, expression) => expression,
+  visitQueryExpression: query => query,
+  visitViewUnit: (fromType, unit) => fixViewUnit(schema, fromType, unit)
+});
+
+const visitAxis = (axis, visitor) => {
+  if (!axis) {
+    return axis;
+  }
+
+  const fromType = ___default["default"].get(axis, ["query", "q/from"]);
+
+  const firstOrNull = x => ___default["default"].first(x) || null;
+
+  const axisResult = _extends({}, axis, {
+    query: axis.query && visitor.visitQueryExpression(axis.query),
+    contextExpression: axis.contextExpression && visitor.visitExpression(fromType, axis.contextExpression),
+    units: axis.units && axis.units.map(unit => visitViewUnit(fromType, unit, visitor)).filter(unit => isUnitExpressionValid(unit)),
+    groupByExpression: axis.groupByExpression && firstOrNull(visitor.visitExpression(fromType, [axis.groupByExpression]))
+  });
+
+  if (!axisResult.query) {
+    return null;
+  }
+
+  if (!axisResult.units) {
+    delete axisResult.units;
+  }
+
+  return axisResult;
+};
+
+const visitView = (view, visitor) => immutableUpdate__default["default"](view, {
+  "fibery/meta": {
+    y: {
+      $apply: y => visitAxis(y, visitor)
+    },
+    items: {
+      $apply: items => items.map(item => {
+        const fromType = ___default["default"].get(item, ["query", "q/from"]);
+
+        return fromType ? immutableUpdate__default["default"](item, {
+          yExpression: {
+            $apply: yExpression => yExpression ? visitor.visitExpression(fromType, yExpression) : yExpression
+          },
+          startExpression: {
+            $apply: startExpression => startExpression ? visitor.visitExpression(fromType, startExpression) : startExpression
+          },
+          endExpression: {
+            $apply: endExpression => endExpression ? visitor.visitExpression(fromType, endExpression) : endExpression
+          },
+          contextExpression: {
+            $apply: contextExpression => contextExpression ? visitor.visitExpression(fromType, contextExpression) : contextExpression
+          },
+          query: {
+            $apply: query => query ? visitor.visitQueryExpression(query) : null
+          },
+          units: {
+            $apply: units => units ? units.map(unit => visitViewUnit(fromType, unit, visitor)).filter(unit => isUnitExpressionValid(unit)).map(unit => visitor.visitViewUnit ? visitor.visitViewUnit(fromType, unit) : unit) : undefined
+          },
+          colorCoding: {
+            $apply: colorCodings => {
+              return colorCodings && colorCodings.map(colorCoding => _extends({}, colorCoding, {
+                expression: visitor.visitExpression(fromType, colorCoding.expression)
+              })).filter(colorCoding => colorCoding.expression !== null);
+            }
+          }
+        }) : item;
+      }).filter(item => {
+        const {
+          query
+        } = item;
+        return query ? item : null;
+      })
+    },
+    milestones: {
+      $apply: milestones => {
+        if (!milestones) {
+          return milestones;
+        }
+
+        return milestones.map(item => {
+          const fromType = ___default["default"].get(item, ["query", "q/from"]);
+
+          return fromType ? immutableUpdate__default["default"](item, {
+            dateExpression: {
+              $apply: startExpression => startExpression ? visitor.visitExpression(fromType, startExpression) : startExpression
+            },
+            query: {
+              $apply: query => query ? visitor.visitQueryExpression(query) : null
+            }
+          }) : item;
+        }).filter(item => {
+          const {
+            query
+          } = item;
+          return query ? item : null;
+        });
+      }
+    }
+  }
+});
+
+const replaceNamesWithIdsInTimelineView = (schema, view) => {
+  return visitView(view, {
+    visitQueryExpression: query => replaceNamesWithIdsInQueryExpression(schema, query),
+    visitExpression: (fromType, expression) => replaceNamesWithIdsInExpression(schema, fromType, expression)
+  });
+};
+const replaceIdsWithNamesInTimelineView = (schema, view) => {
+  return visitView(view, {
+    visitQueryExpression: query => replaceIdsWithNamesInQueryExpression(schema, query),
+    visitExpression: (fromType, expression) => replaceIdsWithNamesInExpression(schema, fromType, expression)
+  });
+};
+
+const ensureAxisAndItemExpressionInvariant = view => {
+  const actions = [];
+
+  const y = ___default["default"].get(view, ["fibery/meta", "y"]);
+
+  const yQuery = ___default["default"].get(view, ["fibery/meta", "y", "query"]);
+
+  const yGroupByExpression = ___default["default"].get(view, ["fibery/meta", "y", "groupByExpression"]);
+
+  const items = ___default["default"].get(view, ["fibery/meta", "items"]);
+
+  if (yQuery === null && yGroupByExpression !== null) {
+    actions.push(() => ___default["default"].set(view, ["fibery/meta", "y", "groupByExpression"], null));
+  }
+
+  if (y === null) {
+    const resetActions = items.map(item => () => item.yExpression = null);
+    actions.push(...resetActions);
+  }
+
+  if (y !== null && ___default["default"].some(items, ({
+    yExpression
+  }) => yExpression === null)) {
+    const resetActions = items.map(item => () => item.yExpression = null);
+    actions.push(...resetActions);
+    actions.push(() => ___default["default"].set(view, ["fibery/meta", "y"], null));
+  }
+
+  if (y !== null && ___default["default"].isEmpty(items)) {
+    actions.push(() => ___default["default"].set(view, ["fibery/meta", "y"], null));
+  }
+
+  actions.forEach(action => action());
+  return view;
+};
+
+const deleteExpressionWithNotFoundFieldsOrTypesInTimelineView = (schema, view, ensureAxisInvariant = true) => {
+  const viewNew = visitView(view, {
+    visitQueryExpression: queryExpression => deleteExpressionWithNotFoundFieldsOrTypesInQueryExpression(schema, queryExpression),
+    visitExpression: (fromType, expression) => deleteExpressionWithNotFoundFieldsOrTypesInExpression(schema, fromType, expression)
+  });
+  return ensureAxisInvariant ? ensureAxisAndItemExpressionInvariant(viewNew) : viewNew;
+};
+const fixUserSelectedUnitsInTimelineView = (schema, view) => {
+  return visitView(view, {
+    visitQueryExpression: query => query,
+    visitExpression: (fromType, expression) => expression,
+    visitViewUnit: (fromType, unit) => fixViewUnit(schema, fromType, unit)
+  });
+};
+
+const deleteExpressionWithNotFoundFieldsOrTypesInView = (schema, view, ensureAxisInvariant = true) => {
+  switch (view["fibery/type"]) {
+    case "board":
+      return deleteExpressionWithNotFoundOrInvalidFieldsOrTypesInBoardView(schema, view, ensureAxisInvariant);
+
+    case "list":
+      return deleteExpressionWithNotFoundFieldsOrTypesInSmartFolder(schema, view);
+
+    case "timeline":
+      return deleteExpressionWithNotFoundFieldsOrTypesInTimelineView(schema, view, ensureAxisInvariant);
+
+    case "calendar":
+      return deleteExpressionWithNotFoundFieldsOrTypesInCalendarView(schema, view);
+
+    case "table":
+      return deleteExpressionWithNotFoundFieldsOrTypesInTableView(schema, view);
+
+    case "feed":
+      return deleteExpressionWithNotFoundFieldsOrTypesInFeedView(schema, view);
+
+    default:
+      return view;
+  }
+};
+const fixUserSelectedUnits = (schema, view) => {
+  switch (view["fibery/type"]) {
+    case "board":
+      return fixUserSelectedUnitsInBoardView(schema, view);
+
+    case "list":
+      return fixUserSelectedUnitsInSmartFolder(schema, view);
+
+    case "table":
+      return fixUserSelectedUnitsInTableView(schema, view);
+
+    case "timeline":
+      return fixUserSelectedUnitsInTimelineView(schema, view);
+
+    case "calendar":
+      return fixUserSelectedUnitsInCalendarView(schema, view);
+
+    case "feed":
+      return fixUserSelectedUnitsInFeedView(schema, view);
+
+    default:
+      return view;
+  }
+};
+const replaceNamesWithIdsInView = (schema, view) => {
+  switch (view["fibery/type"]) {
+    case "board":
+      return replaceNamesWithIdsInBoardView(schema, view);
+
+    case "list":
+      return replaceNamesWithIdsInSmartFolder(schema, view);
+
+    case "table":
+      return replaceNamesWithIdsInTableView(schema, view);
+
+    case "timeline":
+      return replaceNamesWithIdsInTimelineView(schema, view);
+
+    case "calendar":
+      return replaceNamesWithIdsInCalendarView(schema, view);
+
+    case "feed":
+      return replaceNamesWithIdsInFeedView(schema, view);
+
+    default:
+      return view;
+  }
+};
+const replaceIdsWithNamesInView = (schema, view) => {
+  switch (view["fibery/type"]) {
+    case "board":
+      return replaceIdsWithNamesInBoardView(schema, view);
+
+    case "list":
+      return replaceIdsWithNamesInSmartFolder(schema, view);
+
+    case "table":
+      return replaceIdsWithNamesInTableView(schema, view);
+
+    case "timeline":
+      return replaceIdsWithNamesInTimelineView(schema, view);
+
+    case "calendar":
+      return replaceIdsWithNamesInCalendarView(schema, view);
+
+    case "feed":
+      return replaceIdsWithNamesInFeedView(schema, view);
+
+    default:
+      return view;
+  }
+};
+const getViewCardTypes = ({
+  "fibery/meta": {
+    items
+  }
+}) => items.map(({
+  query: {
+    "q/from": type
+  }
+}) => type);
+
+exports.deleteExpressionWithNotFoundFieldsOrTypesInSmartFolder = deleteExpressionWithNotFoundFieldsOrTypesInSmartFolder;
+exports.deleteExpressionWithNotFoundFieldsOrTypesInView = deleteExpressionWithNotFoundFieldsOrTypesInView;
+exports.fixUserSelectedUnits = fixUserSelectedUnits;
+exports.getViewCardTypes = getViewCardTypes;
+exports.replaceIdsWithNamesInSmartFolder = replaceIdsWithNamesInSmartFolder;
+exports.replaceIdsWithNamesInView = replaceIdsWithNamesInView;
+exports.replaceNamesWithIdsInSmartFolder = replaceNamesWithIdsInSmartFolder;
+exports.replaceNamesWithIdsInView = replaceNamesWithIdsInView;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fibery/views",
-  "version": "1.1.2",
+  "version": "1.1.5",
   "description": "Operations on view objects",
   "license": "UNLICENSED",
   "author": "Fibery",
@@ -13,11 +13,12 @@
   "dependencies": {},
   "devDependencies": {
     "@babel/core": "7.15.0",
-    "babel-jest": "27.0.6",
-    "babel-loader": "8.2.2",
-    "babel-preset-fibery": "7.2.0",
-    "eslint-config-fibery": "7.0.0",
-    "jest": "27.0.6",
+    "babel-jest": "27.5.1",
+    "babel-loader": "8.2.5",
+    "@fibery/babel-preset": "7.2.0",
+    "@fibery/eslint-config": "7.1.0",
+    "jest": "27.5.1",
+    "jest-junit": "13.0.0",
     "microbundle": "0.14.1"
   },
   "peerDependencies": {
@@ -29,15 +30,27 @@
   "scripts": {
     "build": "rm -rf lib && microbundle index.js -o lib -f cjs  --no-compress --target node --sourcemap false",
     "test": "node scripts/test.js",
+    "test:ci": "yarn test --coverage --reporters=default --reporters=jest-junit",
     "lint": "eslint ."
   },
   "jest": {
     "testEnvironment": "node",
+    "coveragePathIgnorePatterns": [
+      "/node_modules/"
+    ],
+    "collectCoverageFrom": [
+      "src/**/*.{js,jsx,ts,tsx}",
+      "!src/**/*.d.ts"
+    ],
+    "coverageReporters": [
+      "text",
+      "cobertura"
+    ],
     "testPathIgnorePatterns": [
       "<rootDir>[/\\\\](build|docs|node_modules|scripts)[/\\\\]"
     ],
     "transform": {
-      "^.+\\.jsx?$": "../fibery-ui/config/jest/babel.js"
+      "^.+\\.(js|jsx|ts|tsx)$": "../fibery-ui/config/jest/babel.js"
     },
     "testURL": "http://localhost"
   }