@fibery/views 13.0.3 → 14.0.0

package/lib/views.js

@@ -1292,10 +1292,7 @@ const enableHideWhenEmptyForCheckedUnits = view => {
   });
 };
 
-const visitAxis = (axis, visitor) => {
-  if (!axis) {
-    return axis;
-  }
+const visitAxisSingle = (axis, visitor) => {
   const fromType = ___default["default"].get(axis, ["query", "q/from"]);
   const firstOrNull = x => ___default["default"].first(x) || null;
   const axisResult = {
@@ -1314,6 +1311,23 @@ const visitAxis = (axis, visitor) => {
   }
   return axisResult;
 };
+const visitAxis = (axis, visitor) => {
+  if (axis && axis.hasOwnProperty("query")) {
+    return visitAxisSingle(axis, visitor);
+  }
+  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 visitView = (view, visitor) => immutableUpdate__default["default"](view, {
   "fibery/meta": {
     y: {
@@ -1403,18 +1417,38 @@ const visitView = (view, visitor) => immutableUpdate__default["default"](view, {
   }
 });
 const replaceNamesWithIdsInTimelineView = (schema, view) => {
-  return visitView(view, {
+  const visitor = {
     visitQueryExpression: query => replaceNamesWithIdsInQueryExpression(schema, query),
     visitFilter: (fromType, expression) => replaceNamesWithIdsInFilter(schema, fromType, expression),
-    visitExpression: (fromType, expression) => replaceNamesWithIdsInExpression(schema, fromType, expression)
-  });
+    visitExpression: (fromType, expression) => replaceNamesWithIdsInExpression(schema, fromType, expression),
+    visitEnums: enums => ___default["default"].entries(enums).reduce((result, [type, axis]) => {
+      if (schema.typeObjectsByName.hasOwnProperty(type)) {
+        const typeObject = schema.typeObjectsByName[type];
+        result[typeObject.id] = visitAxisSingle(axis, visitor);
+      } else {
+        result[type] = axis;
+      }
+      return result;
+    }, {})
+  };
+  return visitView(view, visitor);
 };
 const replaceIdsWithNamesInTimelineView = (schema, view) => {
-  return visitView(view, {
+  const visitor = {
     visitQueryExpression: query => replaceIdsWithNamesInQueryExpression(schema, query),
     visitFilter: (fromType, expression) => replaceIdsWithNamesInFilter(schema, fromType, expression),
-    visitExpression: (fromType, expression) => replaceIdsWithNamesInExpression(schema, fromType, expression)
-  });
+    visitExpression: (fromType, expression) => replaceIdsWithNamesInExpression(schema, fromType, expression),
+    visitEnums: enums => ___default["default"].entries(enums).reduce((result, [typeId, axis]) => {
+      if (schema.typeObjectsById.hasOwnProperty(typeId)) {
+        const typeObject = schema.typeObjectsById[typeId];
+        result[typeObject.name] = visitAxisSingle(axis, visitor);
+      } else {
+        result[typeId] = axis;
+      }
+      return result;
+    }, {})
+  };
+  return visitView(view, visitor);
 };
 const ensureAxisAndItemExpressionInvariant = (view, canGroupMetaItem) => {
   const actions = [];
@@ -1444,11 +1478,25 @@ const ensureAxisAndItemExpressionInvariant = (view, canGroupMetaItem) => {
   return view;
 };
 const deleteExpressionWithNotFoundFieldsOrTypesInTimelineView = (schema, view, ensureAxisInvariant, canGroupMetaItem = () => true) => {
-  const viewNew = visitView(view, {
+  const visitor = {
     visitQueryExpression: queryExpression => deleteExpressionWithNotFoundFieldsOrTypesInQueryExpression(schema, queryExpression),
     visitFilter: (fromType, expression) => deleteExpressionWithNotFoundFieldsOrTypesInFilter(schema, fromType, expression),
-    visitExpression: (fromType, expression) => deleteExpressionWithNotFoundFieldsOrTypesInExpression(schema, fromType, expression)
-  });
+    visitExpression: (fromType, expression) => deleteExpressionWithNotFoundFieldsOrTypesInExpression(schema, fromType, expression),
+    visitEnums: enums => {
+      const enumsNew = ___default["default"].entries(enums).reduce((result, [type, axis]) => {
+        if (schema.typeObjectsByName.hasOwnProperty(type)) {
+          const typeObject = schema.typeObjectsByName[type];
+          const axisResult = visitAxisSingle(axis, visitor);
+          if (axisResult) {
+            result[typeObject.name] = axisResult;
+          }
+        }
+        return result;
+      }, {});
+      return ___default["default"].isEmpty(enumsNew) ? null : enumsNew;
+    }
+  };
+  const viewNew = visitView(view, visitor);
   return ensureAxisInvariant ? ensureAxisAndItemExpressionInvariant(viewNew, canGroupMetaItem) : viewNew;
 };
 const fixUserSelectedUnitsInTimelineView = (schema, view, {
@@ -1462,21 +1510,24 @@ const fixUserSelectedUnitsInTimelineView = (schema, view, {
     visitViewUnit: (fromType, unit, units) => fixViewUnit(schema, fromType, unit, units, {
       unitDefinitions,
       getDefaultUnitTypeForField
-    })
+    }),
+    visitEnums: enums => enums
   });
 };
 const fixContextExpressionWithBrokenPath$1 = (schema, view, defaultContextExpression) => visitView(view, {
   visitExpression: (_fromType, expression) => expression,
   visitFilter: (_fromType, filter) => filter,
   visitQueryExpression: query => query,
-  visitContextExpression: (fromType, expression) => resetContextExpressionIfBroken(schema, fromType, expression, defaultContextExpression)
+  visitContextExpression: (fromType, expression) => resetContextExpressionIfBroken(schema, fromType, expression, defaultContextExpression),
+  visitEnums: enums => enums
 });
 const collectGarbage$1 = view => {
   return visitView(view, {
     visitQueryExpression: query => query,
     visitFilter: (_fromType, filter) => filter,
     visitExpression: (_fromType, expression) => expression,
-    visitViewUnit: (_fromType, unit) => unit.checked ? unit : REMOVE
+    visitViewUnit: (_fromType, unit) => unit.checked ? unit : REMOVE,
+    visitEnums: enums => enums
   });
 };
 const enableHideWhenEmptyForCheckedEditableUnits = view => {
@@ -1485,8 +1536,8 @@ const enableHideWhenEmptyForCheckedEditableUnits = view => {
     visitGroupByExpression: groupBy => groupBy,
     visitExpression: (_fromType, expression) => expression,
     visitFilter: (_fromType, filter) => filter,
-    visitEnums: enums => enums,
-    visitViewUnit: (_fromType, unit) => enableHideWhenEmptyForCheckedEditableUnit(unit)
+    visitViewUnit: (_fromType, unit) => enableHideWhenEmptyForCheckedEditableUnit(unit),
+    visitEnums: enums => enums
   });
 };
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fibery/views",
-  "version": "13.0.3",
+  "version": "14.0.0",
   "description": "Operations on view objects",
   "license": "UNLICENSED",
   "author": "Fibery",
@@ -19,13 +19,13 @@
     "lodash": "4.17.21",
     "microbundle": "0.15.1",
     "@fibery/babel-preset": "7.4.0",
-    "@fibery/expression-utils": "9.1.5",
-    "@fibery/eslint-config": "8.6.1",
-    "@fibery/schema": "10.2.6"
+    "@fibery/expression-utils": "9.2.0",
+    "@fibery/schema": "10.2.7",
+    "@fibery/eslint-config": "8.6.1"
   },
   "peerDependencies": {
-    "@fibery/expression-utils": "^9.1.5",
-    "@fibery/schema": "^10.2.6",
+    "@fibery/expression-utils": "^9.2.0",
+    "@fibery/schema": "^10.2.7",
     "immutability-helper": "^2.4.0",
     "lodash": "^4.17.21"
   },

package/src/index.js

@@ -0,0 +1,228 @@
+import immutableUpdate from "immutability-helper";
+import _ from "lodash";
+import * as board from "./private/board";
+import * as calendar from "./private/calendar";
+import * as feed from "./private/feed";
+import * as form from "./private/form";
+import * as map from "./private/map";
+import * as smartfolder from "./private/smart-folder";
+import * as timeline from "./private/timeline";
+import {REMOVE} from "./private/utils";
+
+export {
+  deleteExpressionWithNotFoundFieldsOrTypesInSmartFolder,
+  replaceIdsWithNamesInSmartFolder,
+  replaceNamesWithIdsInSmartFolder,
+} from "./private/smart-folder";
+
+export const deleteExpressionWithNotFoundFieldsOrTypesInView = (schema, view, ensureAxisInvariant = true) => {
+  switch (view["fibery/type"]) {
+    case "board":
+      return board.deleteExpressionWithNotFoundOrInvalidFieldsOrTypesInBoardView(schema, view, ensureAxisInvariant);
+    case "list":
+    case "grid":
+    case "table":
+      return smartfolder.deleteExpressionWithNotFoundFieldsOrTypesInSmartFolder(schema, view);
+    case "timeline":
+      return timeline.deleteExpressionWithNotFoundFieldsOrTypesInTimelineView(
+        schema,
+        view,
+        ensureAxisInvariant,
+        () => true
+      );
+    case "gantt":
+      return timeline.deleteExpressionWithNotFoundFieldsOrTypesInTimelineView(
+        schema,
+        view,
+        ensureAxisInvariant,
+        // Only hierarchy top level meta items can be grouped
+        (metaItem) => !metaItem.groupBy
+      );
+    case "calendar":
+      return calendar.deleteExpressionWithNotFoundFieldsOrTypesInCalendarView(schema, view);
+    case "feed":
+      return feed.deleteExpressionWithNotFoundFieldsOrTypesInFeedView(schema, view);
+    case "form":
+      return form.deleteExpressionWithNotFoundFieldsOrTypesInFormView(schema, view);
+    case "map":
+      return map.deleteExpressionWithNotFoundFieldsOrTypesInMapView(schema, view);
+    default:
+      return view;
+  }
+};
+
+export const fixUserSelectedUnits = (schema, view, {unitDefinitions, getDefaultUnitTypeForField}) => {
+  switch (view["fibery/type"]) {
+    case "board":
+      return board.fixUserSelectedUnitsInBoardView(schema, view, {unitDefinitions, getDefaultUnitTypeForField});
+    case "list":
+    case "grid":
+    case "table":
+      return smartfolder.fixUserSelectedUnitsInSmartFolder(schema, view, {unitDefinitions, getDefaultUnitTypeForField});
+    case "timeline":
+    case "gantt":
+      return timeline.fixUserSelectedUnitsInTimelineView(schema, view, {unitDefinitions, getDefaultUnitTypeForField});
+    case "calendar":
+      return calendar.fixUserSelectedUnitsInCalendarView(schema, view, {unitDefinitions, getDefaultUnitTypeForField});
+    case "feed":
+      return feed.fixUserSelectedUnitsInFeedView(schema, view, {unitDefinitions, getDefaultUnitTypeForField});
+    case "map":
+      return map.fixUserSelectedUnitsInMapView(schema, view, {unitDefinitions, getDefaultUnitTypeForField});
+    default:
+      return view;
+  }
+};
+
+export const fixContextExpressionWithBrokenPath = (schema, view, defaultContextExpression) => {
+  switch (view["fibery/type"]) {
+    case "board":
+      return board.fixContextExpressionWithBrokenPath(schema, view, defaultContextExpression);
+    case "list":
+    case "grid":
+    case "table":
+      return smartfolder.fixContextExpressionWithBrokenPath(schema, view, defaultContextExpression);
+    case "timeline":
+    case "gantt":
+      return timeline.fixContextExpressionWithBrokenPath(schema, view, defaultContextExpression);
+    case "calendar":
+      return calendar.fixContextExpressionWithBrokenPath(schema, view, defaultContextExpression);
+    case "feed":
+      return feed.fixContextExpressionWithBrokenPath(schema, view, defaultContextExpression);
+    case "map":
+      return map.fixContextExpressionWithBrokenPath(schema, view, defaultContextExpression);
+    default:
+      return view;
+  }
+};
+
+/**
+ * Removes garbage from view's meta to reduce the size.
+ */
+export const collectGarbage = (schema, view) => {
+  const deleteRemoved = (x) => {
+    if (Array.isArray(x)) {
+      return x.map(deleteRemoved).filter((y) => y !== REMOVE);
+    }
+    if (typeof x === "object" && x !== null) {
+      let tmp = Object.entries(x);
+      tmp = tmp.map((e) => [e[0], deleteRemoved(e[1])]);
+      tmp = tmp.filter((e) => e[1] !== REMOVE);
+      return Object.fromEntries(tmp);
+    }
+    return x;
+  };
+
+  switch (view["fibery/type"]) {
+    case "board":
+      return deleteRemoved(board.collectGarbage(view));
+    case "list":
+    case "grid":
+    case "table":
+      return deleteRemoved(smartfolder.collectGarbage(view));
+    case "timeline":
+    case "gantt":
+      return deleteRemoved(timeline.collectGarbage(view));
+    case "calendar":
+      return deleteRemoved(calendar.collectGarbage(view));
+    case "feed":
+      return deleteRemoved(feed.collectGarbage(view));
+    case "map":
+      return deleteRemoved(map.collectGarbage(view));
+    default:
+      return view;
+  }
+};
+
+export const replaceNamesWithIdsInView = (schema, view) => {
+  switch (view["fibery/type"]) {
+    case "board":
+      return board.replaceNamesWithIdsInBoardView(schema, view);
+    case "list":
+    case "grid":
+    case "table":
+      return smartfolder.replaceNamesWithIdsInSmartFolder(schema, view);
+    case "timeline":
+    case "gantt":
+      return timeline.replaceNamesWithIdsInTimelineView(schema, view);
+    case "calendar":
+      return calendar.replaceNamesWithIdsInCalendarView(schema, view);
+    case "feed":
+      return feed.replaceNamesWithIdsInFeedView(schema, view);
+    case "form":
+      return form.replaceNamesWithIdsInFormView(schema, view);
+    case "map":
+      return map.replaceNamesWithIdsInMapView(schema, view);
+    default:
+      return view;
+  }
+};
+
+export const replaceIdsWithNamesInView = (schema, view) => {
+  switch (view["fibery/type"]) {
+    case "board":
+      return board.replaceIdsWithNamesInBoardView(schema, view);
+    case "list":
+    case "grid":
+    case "table":
+      return smartfolder.replaceIdsWithNamesInSmartFolder(schema, view);
+    case "timeline":
+    case "gantt":
+      return timeline.replaceIdsWithNamesInTimelineView(schema, view);
+    case "calendar":
+      return calendar.replaceIdsWithNamesInCalendarView(schema, view);
+    case "feed":
+      return feed.replaceIdsWithNamesInFeedView(schema, view);
+    case "form":
+      return form.replaceIdsWithNamesInFormView(schema, view);
+    case "map":
+      return map.replaceIdsWithNamesInMapView(schema, view);
+    default:
+      return view;
+  }
+};
+
+export const getViewCardTypes = ({"fibery/meta": {items}}) => items.map(({query: {"q/from": type}}) => type);
+
+export const migrateHideWhenEmptyToUnitsLevel = (view) => {
+  const viewTypesToTransform = ["board", "list", "timeline", "gantt", "calendar", "feed", "map"];
+  const viewType = view["fibery/type"];
+
+  if (!viewTypesToTransform.includes(viewType)) {
+    return view;
+  }
+
+  const showEmptyUnitValues = _.get(view, ["fibery/meta", "showEmptyUnitValues"]);
+  if (showEmptyUnitValues === undefined) {
+    return view;
+  }
+
+  let result = immutableUpdate(view, {
+    "fibery/meta": {
+      $apply: (x) => _.omit(x, "showEmptyUnitValues"),
+    },
+  });
+
+  if (showEmptyUnitValues === true) {
+    return result;
+  }
+
+  switch (result["fibery/type"]) {
+    case "board":
+      result = board.enableHideWhenEmptyForCovers(result);
+      result = board.enableHideWhenEmptyForCheckedEditableUnits(result);
+      return result;
+    case "list":
+      return smartfolder.enableHideWhenEmptyForCheckedUnits(result);
+    case "timeline":
+    case "gantt":
+      return timeline.enableHideWhenEmptyForCheckedEditableUnits(result);
+    case "calendar":
+      return calendar.enableHideWhenEmptyForCheckedUnits(result);
+    case "feed":
+      return feed.enableHideWhenEmptyForCheckedUnits(result);
+    case "map":
+      return map.enableHideWhenEmptyForCheckedUnits(result);
+    default:
+      return result;
+  }
+};