@fibery/views 10.4.0 → 10.6.0

package/lib/views.js

@@ -868,9 +868,9 @@ const visitSmartFolder = (smartFolder, visitor) => immutableUpdate__default["def
                 if (!groupBy) {
                   return null;
                 }
-                const groupByIndex = parseInt(Object.keys(groupBy)[0]);
-                const removedItemsBeforeTarget = removedItemsIndexes.filter(n => n < groupByIndex);
-                return visitor.visitGroupByExpression(groupBy, fromType, removedItemsBeforeTarget.length);
+                const groupByIndexes = Object.keys(groupBy).map(key => parseInt(key));
+                const removedItemsBeforeTargetLengths = groupByIndexes.map(groupByIndex => removedItemsIndexes.filter(n => n < groupByIndex).length);
+                return visitor.visitGroupByExpression(groupBy, fromType, removedItemsBeforeTargetLengths);
               }
             }
           }) : item;
@@ -885,9 +885,9 @@ const visitSmartFolder = (smartFolder, visitor) => immutableUpdate__default["def
                 if (!groupingExpression) {
                   return null;
                 }
-                const groupingExpressionIndex = parseInt(Object.keys(groupingExpression)[0]);
-                const removedItemsBeforeTarget = removedItemsIndexes.filter(n => n < groupingExpressionIndex);
-                return visitor.visitGroupByExpression(groupingExpression, fromType, removedItemsBeforeTarget.length);
+                const groupingExpressionIndexes = Object.keys(groupingExpression).map(key => parseInt(key));
+                const removedItemsBeforeTargetLengths = groupingExpressionIndexes.map(groupByIndex => removedItemsIndexes.filter(n => n < groupByIndex).length);
+                return visitor.visitGroupByExpression(groupingExpression, fromType, removedItemsBeforeTargetLengths);
               }
             }
           }) : item;
@@ -924,6 +924,32 @@ const visitSmartFolder = (smartFolder, visitor) => immutableUpdate__default["def
           return query ? item : null;
         });
       }
+    },
+    columnOrderWithIds: {
+      $apply: columnOrderWithIds => {
+        if (!visitor.visitUnitGroupKey || !columnOrderWithIds) {
+          return columnOrderWithIds;
+        }
+        return columnOrderWithIds.map(key => visitor.visitUnitGroupKey(key));
+      }
+    },
+    pinnedColumnsWithIds: {
+      $apply: pinnedColumnsWithIds => {
+        if (!visitor.visitUnitGroupKey || !pinnedColumnsWithIds) {
+          return pinnedColumnsWithIds;
+        }
+        return pinnedColumnsWithIds.map(key => visitor.visitUnitGroupKey(key));
+      }
+    },
+    columnAggFunc: {
+      $apply: columnAggFunc => {
+        if (!visitor.visitUnitGroupKey || !columnAggFunc) {
+          return columnAggFunc;
+        }
+        return Object.fromEntries(Object.entries(columnAggFunc).map(([key, value]) => {
+          return [visitor.visitUnitGroupKey(key), value];
+        }));
+      }
     }
   }
 });
@@ -933,10 +959,10 @@ const deleteExpressionWithNotFoundFieldsOrTypesInGroupByExpression = (schema, gr
   }
   const entries = Object.entries(groupByExpression).map(([index, {
     expression
-  }]) => {
+  }], groupByIndex) => {
     const visitedExpression = deleteExpressionWithNotFoundFieldsOrTypesInExpression(schema, fromType, expression);
     if (visitedExpression) {
-      return [`${parseInt(index) - removedItems}`, {
+      return [`${parseInt(index) - removedItems[groupByIndex]}`, {
         expression: visitedExpression
       }];
     }
@@ -984,13 +1010,68 @@ const replaceNamesWithIdsInGroupByExpression = (schema, groupByExpression, fromT
 };
 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)
+  visitGroupByExpression: (groupBy, fromType) => replaceNamesWithIdsInGroupByExpression(schema, groupBy, fromType, Object.keys(groupBy).map(() => 0)),
+  visitExpression: (fromType, expression) => replaceNamesWithIdsInExpression(schema, fromType, expression),
+  visitUnitGroupKey: unitGroupKey => {
+    const keyParts = unitGroupKey.split("|");
+    return keyParts.map(keyPart => {
+      const [unitType, ...rest] = keyPart.split("_");
+      if (unitType === "user-button") {
+        return keyPart;
+      }
+      const name = rest.join("_");
+      if (!name) {
+        return keyPart;
+      }
+      const [type, field] = name.split(":");
+      if (!field) {
+        return keyPart;
+      }
+      if (!(type in schema.typeObjectsByName)) {
+        return keyPart;
+      }
+      const typeObject = schema.typeObjectsByName[type];
+      if (!(field in typeObject.fieldObjectsByName)) {
+        return keyPart;
+      }
+      const fieldObject = typeObject.fieldObjectsByName[field];
+      return `${unitType}_${fieldObject.id}`;
+    }).filter(Boolean).join("|");
+  }
 });
 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)
+  visitGroupByExpression: (groupBy, fromType) => replaceIdsWithNamesInGroupByExpression(schema, groupBy, fromType, Object.keys(groupBy).map(() => 0)),
+  visitExpression: (fromType, expression) => replaceIdsWithNamesInExpression(schema, fromType, expression),
+  visitUnitGroupKey: unitGroupKey => {
+    const types = smartFolder["fibery/meta"].items.map(item => item.query["q/from"]);
+    const fieldObjectsById = types.reduce((acc, type) => {
+      if (!(type in schema.typeObjectsById)) {
+        return acc;
+      }
+      const fieldObjects = schema.typeObjectsById[type].fieldObjectsById;
+      return {
+        ...acc,
+        ...fieldObjects
+      };
+    }, {});
+    const keyParts = unitGroupKey.split("|");
+    return keyParts.map(keyPart => {
+      const [unitType, ...rest] = keyPart.split("_");
+      if (unitType === "user-button") {
+        return keyPart;
+      }
+      const fieldId = rest.join("_");
+      if (!fieldId) {
+        return keyPart;
+      }
+      const fieldObject = fieldObjectsById[fieldId];
+      if (!fieldObject) {
+        return keyPart;
+      }
+      return `${unitType}_${fieldObject.holderType}:${fieldObject.name}`;
+    }).filter(Boolean).join("|");
+  }
 });
 const deleteExpressionWithNotFoundFieldsOrTypesInSmartFolder = (schema, smartFolder) => visitSmartFolder(smartFolder, {
   visitQueryExpression: query => deleteExpressionWithNotFoundFieldsOrTypesInQueryExpression(schema, query),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fibery/views",
-  "version": "10.4.0",
+  "version": "10.6.0",
   "description": "Operations on view objects",
   "license": "UNLICENSED",
   "author": "Fibery",
@@ -20,8 +20,8 @@
     "microbundle": "0.15.1",
     "@fibery/babel-preset": "7.4.0",
     "@fibery/eslint-config": "8.6.0",
-    "@fibery/expression-utils": "9.0.5",
-    "@fibery/schema": "10.2.1"
+    "@fibery/schema": "10.2.1",
+    "@fibery/expression-utils": "9.0.5"
   },
   "peerDependencies": {
     "@fibery/expression-utils": "^9.0.5",