@fibery/views 17.0.4 → 18.0.2

package/lib/src/private/map.d.ts

@@ -0,0 +1,10 @@
+export function replaceNamesWithIdsInMapView(schema: any, view: any): any;
+export function replaceIdsWithNamesInMapView(schema: any, view: any): any;
+export function deleteExpressionWithNotFoundFieldsOrTypesInMapView(schema: any, view: any): any;
+export function fixUserSelectedUnitsInMapView(schema: any, view: any, { unitDefinitions, getDefaultUnitTypeForField }: {
+    unitDefinitions: any;
+    getDefaultUnitTypeForField: any;
+}): any;
+export function fixContextExpressionWithBrokenPath(schema: any, view: any, defaultContextExpression: any): any;
+export function collectGarbage(view: any): any;
+export function enableHideWhenEmptyForCheckedUnits(view: any): any;

package/lib/src/private/map.js

@@ -0,0 +1,119 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.enableHideWhenEmptyForCheckedUnits = exports.collectGarbage = exports.fixContextExpressionWithBrokenPath = exports.fixUserSelectedUnitsInMapView = exports.deleteExpressionWithNotFoundFieldsOrTypesInMapView = exports.replaceIdsWithNamesInMapView = exports.replaceNamesWithIdsInMapView = void 0;
+const immutability_helper_1 = __importDefault(require("immutability-helper"));
+const get_1 = __importDefault(require("lodash/get"));
+const units_1 = require("./units");
+const utils_1 = require("./utils");
+const visitView = (view, visitor) => (0, immutability_helper_1.default)(view, {
+    "fibery/meta": {
+        items: {
+            $apply: (items) => items
+                .map((item) => {
+                const fromType = (0, get_1.default)(item, ["query", "q/from"]);
+                return fromType
+                    ? (0, immutability_helper_1.default)(item, {
+                        locationExpression: {
+                            $apply: (startExpression) => startExpression ? visitor.visitExpression(fromType, startExpression) : startExpression,
+                        },
+                        contextExpression: {
+                            $apply: (contextExpression) => (0, utils_1.visitContextExpression)(fromType, contextExpression, visitor),
+                        },
+                        query: {
+                            $apply: (query) => (query ? visitor.visitQueryExpression(query) : null),
+                        },
+                        filter: {
+                            $apply: (filter) => (filter ? visitor.visitFilter(fromType, filter) : null),
+                        },
+                        units: {
+                            $apply: (units) => units
+                                ? units
+                                    .filter((unit) => Boolean(unit))
+                                    .map((unit) => (0, utils_1.visitViewUnit)(fromType, unit, visitor))
+                                    .filter((unit) => (0, utils_1.isUnitExpressionValid)(unit))
+                                    .map((unit, idx, units) => visitor.visitViewUnit ? visitor.visitViewUnit(fromType, unit, units) : unit)
+                                    .filter((unit) => unit !== utils_1.REMOVE)
+                                : undefined,
+                        },
+                        colorCoding: {
+                            $apply: (colorCodings) => {
+                                return (colorCodings &&
+                                    colorCodings
+                                        .map((colorCoding) => ({
+                                        ...colorCoding,
+                                        expression: visitor.visitExpression(fromType, colorCoding.expression),
+                                    }))
+                                        .filter((colorCoding) => colorCoding.expression !== null));
+                            },
+                        },
+                    })
+                    : item;
+            })
+                .filter((item) => {
+                const { query } = item;
+                return query ? item : null;
+            }),
+        },
+    },
+});
+const replaceNamesWithIdsInMapView = (schema, view) => {
+    return visitView(view, {
+        visitQueryExpression: (query) => (0, utils_1.replaceNamesWithIdsInQueryExpression)(schema, query),
+        visitFilter: (fromType, expression) => (0, utils_1.replaceNamesWithIdsInFilter)(schema, fromType, expression),
+        visitExpression: (fromType, expression) => (0, utils_1.replaceNamesWithIdsInExpression)(schema, fromType, expression),
+    });
+};
+exports.replaceNamesWithIdsInMapView = replaceNamesWithIdsInMapView;
+const replaceIdsWithNamesInMapView = (schema, view) => {
+    return visitView(view, {
+        visitQueryExpression: (query) => (0, utils_1.replaceIdsWithNamesInQueryExpression)(schema, query),
+        visitFilter: (fromType, expression) => (0, utils_1.replaceIdsWithNamesInFilter)(schema, fromType, expression),
+        visitExpression: (fromType, expression) => (0, utils_1.replaceIdsWithNamesInExpression)(schema, fromType, expression),
+    });
+};
+exports.replaceIdsWithNamesInMapView = replaceIdsWithNamesInMapView;
+const deleteExpressionWithNotFoundFieldsOrTypesInMapView = (schema, view) => visitView(view, {
+    visitQueryExpression: (queryExpression) => (0, utils_1.deleteExpressionWithNotFoundFieldsOrTypesInQueryExpression)(schema, queryExpression),
+    visitFilter: (fromType, expression) => (0, utils_1.deleteExpressionWithNotFoundFieldsOrTypesInFilter)(schema, fromType, expression),
+    visitExpression: (fromType, expression) => (0, utils_1.deleteExpressionWithNotFoundFieldsOrTypesInExpression)(schema, fromType, expression),
+});
+exports.deleteExpressionWithNotFoundFieldsOrTypesInMapView = deleteExpressionWithNotFoundFieldsOrTypesInMapView;
+const fixUserSelectedUnitsInMapView = (schema, view, { unitDefinitions, getDefaultUnitTypeForField }) => {
+    return visitView(view, {
+        visitQueryExpression: (query) => query,
+        visitFilter: (_fromType, filter) => filter,
+        visitExpression: (_fromType, expression) => expression,
+        visitViewUnit: (fromType, unit, units) => (0, units_1.fixViewUnit)(schema, fromType, unit, units, { unitDefinitions, getDefaultUnitTypeForField }),
+    });
+};
+exports.fixUserSelectedUnitsInMapView = fixUserSelectedUnitsInMapView;
+const fixContextExpressionWithBrokenPath = (schema, view, defaultContextExpression) => visitView(view, {
+    visitExpression: (_fromType, expression) => expression,
+    visitQueryExpression: (query) => query,
+    visitFilter: (_fromType, filter) => filter,
+    visitContextExpression: (fromType, expression) => (0, utils_1.resetContextExpressionIfBroken)(schema, fromType, expression, defaultContextExpression),
+});
+exports.fixContextExpressionWithBrokenPath = fixContextExpressionWithBrokenPath;
+const collectGarbage = (view) => {
+    return visitView(view, {
+        visitQueryExpression: (query) => query,
+        visitFilter: (_fromType, filter) => filter,
+        visitExpression: (_fromType, expression) => expression,
+        visitViewUnit: (_fromType, unit) => (unit.checked ? unit : utils_1.REMOVE),
+    });
+};
+exports.collectGarbage = collectGarbage;
+const enableHideWhenEmptyForCheckedUnits = (view) => {
+    return visitView(view, {
+        visitQueryExpression: (queryExpression) => queryExpression,
+        visitGroupByExpression: (groupBy) => groupBy,
+        visitFilter: (_fromType, filter) => filter,
+        visitExpression: (_fromType, expression) => expression,
+        visitEnums: (enums) => enums,
+        visitViewUnit: (_fromType, unit) => (0, units_1.enableHideWhenEmptyForCheckedEditableUnit)(unit),
+    });
+};
+exports.enableHideWhenEmptyForCheckedUnits = enableHideWhenEmptyForCheckedUnits;

package/lib/src/private/smart-folder.d.ts

@@ -0,0 +1,23 @@
+export function deleteExpressionWithNotFoundFieldsOrTypesInGroupByExpression(schema: any, groupByExpression: any, fromType: any, removedItems: any): {
+    [k: string]: any;
+} | null;
+export function replaceIdsWithNamesInGroupByExpression(schema: any, groupByExpression: any, fromType: any): {
+    [k: string]: {
+        expression: any;
+    };
+} | null;
+export function replaceNamesWithIdsInGroupByExpression(schema: any, groupByExpression: any, fromType: any): {
+    [k: string]: {
+        expression: any;
+    };
+} | null;
+export function replaceNamesWithIdsInSmartFolder(schema: any, smartFolder: any): any;
+export function replaceIdsWithNamesInSmartFolder(schema: any, smartFolder: any): any;
+export function deleteExpressionWithNotFoundFieldsOrTypesInSmartFolder(schema: any, smartFolder: any): any;
+export function fixContextExpressionWithBrokenPath(schema: any, view: any, defaultContextExpression: any): any;
+export function fixUserSelectedUnitsInSmartFolder(schema: any, view: any, { unitDefinitions, getDefaultUnitTypeForField }: {
+    unitDefinitions: any;
+    getDefaultUnitTypeForField: any;
+}): any;
+export function collectGarbage(view: any): any;
+export function enableHideWhenEmptyForCheckedUnits(view: any): any;

package/lib/src/private/smart-folder.js

@@ -0,0 +1,274 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.enableHideWhenEmptyForCheckedUnits = exports.collectGarbage = exports.fixUserSelectedUnitsInSmartFolder = exports.fixContextExpressionWithBrokenPath = exports.deleteExpressionWithNotFoundFieldsOrTypesInSmartFolder = exports.replaceIdsWithNamesInSmartFolder = exports.replaceNamesWithIdsInSmartFolder = exports.replaceNamesWithIdsInGroupByExpression = exports.replaceIdsWithNamesInGroupByExpression = exports.deleteExpressionWithNotFoundFieldsOrTypesInGroupByExpression = void 0;
+const visitors_1 = require("@fibery/expression-utils/src/visitors");
+const immutability_helper_1 = __importDefault(require("immutability-helper"));
+const get_1 = __importDefault(require("lodash/get"));
+const isEqual_1 = __importDefault(require("lodash/isEqual"));
+const units_1 = require("./units");
+const utils_1 = require("./utils");
+const visitSmartFolder = (smartFolder, visitor) => (0, immutability_helper_1.default)(smartFolder, {
+    "fibery/meta": {
+        items: {
+            $apply: (items = []) => {
+                const isOldSmartFolder = !items.every((item) => Object.hasOwn(item, "groupBy"));
+                const removedItemsIndexes = items
+                    .map((item, index) => (visitor.visitQueryExpression(item.query) ? null : index))
+                    .filter((value) => value !== null);
+                return items
+                    .map((item) => {
+                    if (isOldSmartFolder) {
+                        return item;
+                    }
+                    const fromType = (0, get_1.default)(item, ["query", "q/from"]);
+                    return fromType
+                        ? (0, immutability_helper_1.default)(item, {
+                            groupBy: {
+                                $apply: (groupBy) => {
+                                    if (!groupBy) {
+                                        return null;
+                                    }
+                                    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;
+                })
+                    .map((item) => {
+                    if (isOldSmartFolder) {
+                        return item;
+                    }
+                    const fromType = (0, get_1.default)(item, ["query", "q/from"]);
+                    return fromType
+                        ? (0, immutability_helper_1.default)(item, {
+                            groupingExpression: {
+                                $apply: (groupingExpression) => {
+                                    if (!groupingExpression) {
+                                        return null;
+                                    }
+                                    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;
+                })
+                    .map((item) => {
+                    const fromType = (0, get_1.default)(item, ["query", "q/from"]);
+                    return fromType
+                        ? (0, immutability_helper_1.default)(item, {
+                            filter: {
+                                $apply: (filter) => (filter ? visitor.visitFilter(fromType, filter) : null),
+                            },
+                            query: {
+                                $apply: (query) => {
+                                    const visitedQuery = visitor.visitQueryExpression(query);
+                                    return query ? visitedQuery : null;
+                                },
+                            },
+                            units: {
+                                $apply: (units) => {
+                                    return units
+                                        ? units
+                                            .filter((unit) => Boolean(unit))
+                                            .map((unit) => (0, utils_1.visitViewUnit)(fromType, unit, visitor))
+                                            .filter((unit) => (0, utils_1.isUnitExpressionValid)(unit))
+                                            .map((unit, index, units) => visitor.visitViewUnit ? visitor.visitViewUnit(fromType, unit, units) : unit)
+                                            .filter((unit) => unit !== utils_1.REMOVE)
+                                        : undefined;
+                                },
+                            },
+                            contextExpression: {
+                                $apply: (contextExpression) => (0, utils_1.visitContextExpression)(fromType, contextExpression, visitor),
+                            },
+                            colorCoding: {
+                                $apply: (colorCodings) => {
+                                    return colorCodings
+                                        ? colorCodings
+                                            .map((colorCoding) => ({
+                                            ...colorCoding,
+                                            expression: visitor.visitExpression(fromType, colorCoding.expression),
+                                        }))
+                                            .filter((colorCoding) => colorCoding.expression !== null)
+                                        : undefined;
+                                },
+                            },
+                        })
+                        : item;
+                })
+                    .filter((item) => {
+                    const { query } = item;
+                    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];
+                }));
+            },
+        },
+    },
+});
+const deleteExpressionWithNotFoundFieldsOrTypesInGroupByExpression = (schema, groupByExpression, fromType, removedItems) => {
+    if (!groupByExpression) {
+        return null;
+    }
+    const entries = Object.entries(groupByExpression)
+        .map(([index, { expression }], groupByIndex) => {
+        const visitedExpression = (0, utils_1.deleteExpressionWithNotFoundFieldsOrTypesInExpression)(schema, fromType, expression);
+        if (visitedExpression) {
+            return [
+                `${parseInt(index) - removedItems[groupByIndex]}`,
+                {
+                    expression: visitedExpression,
+                },
+            ];
+        }
+        return null;
+    })
+        .filter(Boolean);
+    return entries.length > 0 ? Object.fromEntries(entries) : null;
+};
+exports.deleteExpressionWithNotFoundFieldsOrTypesInGroupByExpression = deleteExpressionWithNotFoundFieldsOrTypesInGroupByExpression;
+const replaceIdsWithNamesInGroupByExpression = (schema, groupByExpression, fromType) => {
+    if (!groupByExpression) {
+        return null;
+    }
+    return Object.fromEntries(Object.entries(groupByExpression).map(([index, { expression }]) => {
+        if (Object.hasOwn(schema.typeObjectsById, fromType)) {
+            const typeObject = schema.typeObjectsById[fromType];
+            return [
+                index,
+                {
+                    expression: (0, visitors_1.replaceIdsWithNamesVisitor)(typeObject).visitExpression(expression),
+                },
+            ];
+        }
+        else {
+            return [index, { expression }];
+        }
+    }));
+};
+exports.replaceIdsWithNamesInGroupByExpression = replaceIdsWithNamesInGroupByExpression;
+const replaceNamesWithIdsInGroupByExpression = (schema, groupByExpression, fromType) => {
+    if (!groupByExpression) {
+        return null;
+    }
+    return Object.fromEntries(Object.entries(groupByExpression).map(([index, { expression }]) => {
+        if (Object.hasOwn(schema.typeObjectsByName, fromType)) {
+            const typeObject = schema.typeObjectsByName[fromType];
+            return [
+                index,
+                {
+                    expression: (0, visitors_1.replaceNamesWithIdsVisitor)(typeObject).visitExpression(expression),
+                },
+            ];
+        }
+        else {
+            return [index, { expression }];
+        }
+    }));
+};
+exports.replaceNamesWithIdsInGroupByExpression = replaceNamesWithIdsInGroupByExpression;
+const replaceNamesWithIdsInSmartFolder = (schema, smartFolder) => visitSmartFolder(smartFolder, {
+    visitQueryExpression: (query) => (0, utils_1.replaceNamesWithIdsInQueryExpression)(schema, query),
+    visitFilter: (fromType, expression) => (0, utils_1.replaceNamesWithIdsInFilter)(schema, fromType, expression),
+    visitGroupByExpression: (groupBy, fromType) => (0, exports.replaceNamesWithIdsInGroupByExpression)(schema, groupBy, fromType),
+    visitExpression: (fromType, expression) => (0, utils_1.replaceNamesWithIdsInExpression)(schema, fromType, expression),
+    visitUnitGroupKey: (unitGroupKey) => (0, utils_1.replaceNamesWithIdsInUnitGroupKey)(unitGroupKey, schema),
+});
+exports.replaceNamesWithIdsInSmartFolder = replaceNamesWithIdsInSmartFolder;
+const replaceIdsWithNamesInSmartFolder = (schema, smartFolder) => visitSmartFolder(smartFolder, {
+    visitQueryExpression: (query) => (0, utils_1.replaceIdsWithNamesInQueryExpression)(schema, query),
+    visitFilter: (fromType, expression) => (0, utils_1.replaceIdsWithNamesInFilter)(schema, fromType, expression),
+    visitGroupByExpression: (groupBy, fromType) => (0, exports.replaceIdsWithNamesInGroupByExpression)(schema, groupBy, fromType),
+    visitExpression: (fromType, expression) => (0, utils_1.replaceIdsWithNamesInExpression)(schema, fromType, expression),
+    visitUnitGroupKey: (unitGroupKey) => (0, utils_1.replaceIdsWithNamesInUnitGroupKey)(unitGroupKey, (0, utils_1.getFieldObjectsById)(smartFolder, schema)),
+});
+exports.replaceIdsWithNamesInSmartFolder = replaceIdsWithNamesInSmartFolder;
+const deleteExpressionWithNotFoundFieldsOrTypesInSmartFolder = (schema, smartFolder) => visitSmartFolder(smartFolder, {
+    visitQueryExpression: (query) => (0, utils_1.deleteExpressionWithNotFoundFieldsOrTypesInQueryExpression)(schema, query),
+    visitGroupByExpression: (groupBy, fromType, removedItems) => (0, exports.deleteExpressionWithNotFoundFieldsOrTypesInGroupByExpression)(schema, groupBy, fromType, removedItems),
+    visitFilter: (fromType, expression) => (0, utils_1.deleteExpressionWithNotFoundFieldsOrTypesInFilter)(schema, fromType, expression),
+    visitExpression: (fromType, expression) => (0, utils_1.deleteExpressionWithNotFoundFieldsOrTypesInExpression)(schema, fromType, expression),
+});
+exports.deleteExpressionWithNotFoundFieldsOrTypesInSmartFolder = deleteExpressionWithNotFoundFieldsOrTypesInSmartFolder;
+const fixContextExpressionWithBrokenPath = (schema, view, defaultContextExpression) => visitSmartFolder(view, {
+    visitQueryExpression: (query) => query,
+    visitGroupByExpression: (groupBy) => groupBy,
+    visitExpression: (_fromType, expression) => expression,
+    visitFilter: (_fromType, filter) => filter,
+    visitContextExpression: (fromType, expression) => (0, utils_1.resetContextExpressionIfBroken)(schema, fromType, expression, defaultContextExpression),
+});
+exports.fixContextExpressionWithBrokenPath = fixContextExpressionWithBrokenPath;
+const fixUserSelectedUnitsInSmartFolder = (schema, view, { unitDefinitions, getDefaultUnitTypeForField }) => {
+    return visitSmartFolder(view, {
+        visitQueryExpression: (query) => query,
+        visitGroupByExpression: (groupBy) => groupBy,
+        visitFilter: (_fromType, filter) => filter,
+        visitExpression: (_fromType, expression) => expression,
+        visitViewUnit: (fromType, unit, units) => {
+            const { type, expression } = unit;
+            if (type === "rich-text" && view?.["fibery/type"] === "grid") {
+                if (unit.checked) {
+                    const snippetsUnits = units?.filter((x) => x.type === "rich-text-snippet");
+                    const snippetUnitForField = snippetsUnits?.find((x) => (0, isEqual_1.default)(x.expression, expression));
+                    if (snippetUnitForField && !snippetUnitForField.checked) {
+                        snippetUnitForField.checked = true;
+                    }
+                }
+                return utils_1.REMOVE;
+            }
+            return (0, units_1.fixViewUnit)(schema, fromType, unit, units, { unitDefinitions, getDefaultUnitTypeForField });
+        },
+    });
+};
+exports.fixUserSelectedUnitsInSmartFolder = fixUserSelectedUnitsInSmartFolder;
+const collectGarbage = (view) => {
+    return visitSmartFolder(view, {
+        visitQueryExpression: (query) => query,
+        visitFilter: (_fromType, filter) => filter,
+        visitGroupByExpression: (groupBy) => groupBy,
+        visitExpression: (_fromType, expression) => expression,
+        visitViewUnit: (_fromType, unit) => (unit.checked ? unit : utils_1.REMOVE),
+    });
+};
+exports.collectGarbage = collectGarbage;
+const enableHideWhenEmptyForCheckedUnits = (view) => {
+    return visitSmartFolder(view, {
+        visitQueryExpression: (queryExpression) => queryExpression,
+        visitGroupByExpression: (groupBy) => groupBy,
+        visitExpression: (_fromType, expression) => expression,
+        visitFilter: (_fromType, filter) => filter,
+        visitEnums: (enums) => enums,
+        visitViewUnit: (_fromType, unit) => (0, units_1.enableHideWhenEmptyForCheckedEditableUnit)(unit),
+    });
+};
+exports.enableHideWhenEmptyForCheckedUnits = enableHideWhenEmptyForCheckedUnits;