@fibery/views 17.0.4 → 18.0.2

package/lib/src/field-utils/reference.js

@@ -0,0 +1,57 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getReferenceFieldNormalizedSelectClause = exports.getReferenceTypeSelectClause = void 0;
+const compact_1 = __importDefault(require("lodash/compact"));
+const select_1 = require("@fibery/query-utils/src/select");
+const access_1 = require("../unit-utils/access");
+const enums_1 = require("../unit-utils/enums");
+const workflow_1 = require("./workflow");
+const avatar_1 = require("./avatar");
+const user_active_1 = require("./user-active");
+const icon_1 = require("./icon");
+const file_1 = require("./file");
+const getReferenceTypeSelectClause = ({ typeObject }, contextPath) => {
+    return {
+        ...(0, select_1.toSelectMapClause)((0, compact_1.default)([
+            typeObject.idField,
+            typeObject.publicIdField,
+            typeObject.titleField,
+            typeObject.rankField,
+            typeObject.name === "fibery/user" ? "user/email" : null,
+        ])),
+        ...(0, access_1.generateAccessCheckQueryExpression)({ typeObject, contextPath }),
+        ...(0, workflow_1.getIsFinalStateSelect)({ typeObject, contextPath }),
+        ...(0, user_active_1.getIsUserActiveSelect)({
+            typeObject,
+            contextPath,
+        }),
+        ...(0, enums_1.getEnumIconColorQuery)({
+            typeObject,
+            contextPath,
+        }),
+        ...(0, avatar_1.getAvatarSelectQuery)({ typeObject }),
+        ...(0, icon_1.getEntityIconSelect)({ typeObject }),
+        ...(typeObject.name === "fibery/file" ? (0, file_1.getFilesSelect)({ typeObject }) : null),
+    };
+};
+exports.getReferenceTypeSelectClause = getReferenceTypeSelectClause;
+const getReferenceFieldNormalizedSelectClause = (fieldObject, contextPath) => {
+    const { typeObject } = fieldObject;
+    if (typeObject.isEntityRef) {
+        const pairs = fieldObject.multiRelatedFieldObjects.map((f) => {
+            const select = (0, exports.getReferenceTypeSelectClause)({ typeObject: f.holderTypeObject }, [
+                contextPath.concat(f.holderType),
+            ]);
+            const normalizedSelect = (0, select_1.normalizeSelect)(select);
+            return [f.holderType, { ...normalizedSelect, [select_1.isSelectForMultiFieldKey]: true }];
+        });
+        return Object.fromEntries(pairs);
+    }
+    else {
+        return (0, select_1.normalizeSelect)((0, exports.getReferenceTypeSelectClause)({ typeObject }, contextPath));
+    }
+};
+exports.getReferenceFieldNormalizedSelectClause = getReferenceFieldNormalizedSelectClause;

package/lib/src/field-utils/relation-view.d.ts

@@ -0,0 +1,2 @@
+import { FieldObject } from "@fibery/schema";
+export declare const isRelationViewField: (fieldObject: FieldObject) => boolean;

package/lib/src/field-utils/relation-view.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isRelationViewField = void 0;
+const isRelationViewField = (fieldObject) => {
+    if (fieldObject.typeObject.isPrimitive ||
+        (!fieldObject.relation && !fieldObject.multiRelation) ||
+        fieldObject.typeObject.isEnum) {
+        return false;
+    }
+    return [":cardinality/one-to-many", ":cardinality/many-to-many"].includes(fieldObject.cardinality);
+};
+exports.isRelationViewField = isRelationViewField;

package/lib/src/field-utils/rich-text.d.ts

@@ -0,0 +1,12 @@
+import { FieldObject, TypeObject } from "@fibery/schema";
+import { FieldUnit } from "../units/types";
+export declare const hasAccessToSecretKey: string;
+export declare const getHasAccessToSecretExpr: (fieldObject: FieldObject) => (string | string[])[];
+export declare const getHasAccessToSecret: (fieldObject: FieldObject) => {
+    [hasAccessToSecretKey]: (string | string[])[];
+};
+export declare function getRichTextQuerySelect({ typeObject, unit: { expression }, includeSnippet, }: {
+    typeObject: TypeObject;
+    unit: FieldUnit;
+    includeSnippet?: boolean;
+}): any;

package/lib/src/field-utils/rich-text.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getHasAccessToSecret = exports.getHasAccessToSecretExpr = exports.hasAccessToSecretKey = void 0;
+exports.getRichTextQuerySelect = getRichTextQuerySelect;
+const select_1 = require("@fibery/query-utils/src/select");
+const utils_1 = require("@fibery/expression-utils/src/utils");
+const dynamic_keys_1 = require("../unit-utils/dynamic-keys");
+exports.hasAccessToSecretKey = (0, dynamic_keys_1.makeDynamicKey)(dynamic_keys_1.hasAccessToSecretKeyPrefix);
+const getHasAccessToSecretExpr = (fieldObject) => [
+    "q/access?",
+    [fieldObject.name, "Collaboration~Documents/secret"],
+];
+exports.getHasAccessToSecretExpr = getHasAccessToSecretExpr;
+const getHasAccessToSecret = (fieldObject) => ({
+    [exports.hasAccessToSecretKey]: (0, exports.getHasAccessToSecretExpr)(fieldObject),
+});
+exports.getHasAccessToSecret = getHasAccessToSecret;
+function getRichTextQuerySelect({ typeObject, unit: { expression }, includeSnippet, }) {
+    const fieldObject = (0, utils_1.getFieldObjectByFieldExpression)({ typeObject, expression });
+    return (0, select_1.denormalizeSelect)({
+        [fieldObject.name]: (0, select_1.normalizeSelect)({
+            ...(0, exports.getHasAccessToSecret)(fieldObject),
+            ...(0, select_1.toSelectMapClause)([typeObject.idField, "Collaboration~Documents/secret"]),
+            ...(includeSnippet ? (0, select_1.toSelectMapClause)([typeObject.idField, "Collaboration~Documents/Snippet"]) : {}),
+        }),
+    });
+}

package/lib/src/field-utils/text.d.ts

@@ -0,0 +1,35 @@
+import { $TSFixMe } from "../tsfixme";
+export declare const TextUIMetaKey = "ui/type";
+export declare const TextUIMeta: {
+    Phone: string;
+    Email: string;
+    URL: string;
+};
+export declare const TextTypes: {
+    CustomPhone: string;
+    CustomEmail: string;
+    CustomURL: string;
+};
+export declare const TextTypeToFiberyType: {
+    [TextTypes.CustomPhone]: string;
+    [TextTypes.CustomEmail]: string;
+    [TextTypes.CustomURL]: string;
+};
+export declare const TextTypeToUiMeta: {
+    [TextTypes.CustomPhone]: {
+        "ui/type": string;
+    };
+    [TextTypes.CustomEmail]: {
+        "ui/type": string;
+    };
+    [TextTypes.CustomURL]: {
+        "ui/type": string;
+    };
+};
+export declare const TextUiMetaToTextType: {
+    [TextUIMeta.Phone]: string;
+    [TextUIMeta.Email]: string;
+    [TextUIMeta.URL]: string;
+};
+export declare const getTextType: (fieldMeta: $TSFixMe) => string;
+export declare const getTextTypeLabel: (textType: string) => string;

package/lib/src/field-utils/text.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getTextTypeLabel = exports.getTextType = exports.TextUiMetaToTextType = exports.TextTypeToUiMeta = exports.TextTypeToFiberyType = exports.TextTypes = exports.TextUIMeta = exports.TextUIMetaKey = void 0;
+exports.TextUIMetaKey = "ui/type";
+exports.TextUIMeta = {
+    Phone: "phone",
+    Email: "email",
+    URL: "url",
+};
+exports.TextTypes = {
+    CustomPhone: "custom/phone",
+    CustomEmail: "custom/email",
+    CustomURL: "custom/url",
+};
+exports.TextTypeToFiberyType = {
+    [exports.TextTypes.CustomPhone]: "fibery/text",
+    [exports.TextTypes.CustomEmail]: "fibery/text",
+    [exports.TextTypes.CustomURL]: "fibery/text",
+};
+exports.TextTypeToUiMeta = {
+    [exports.TextTypes.CustomPhone]: { [exports.TextUIMetaKey]: exports.TextUIMeta.Phone },
+    [exports.TextTypes.CustomEmail]: { [exports.TextUIMetaKey]: exports.TextUIMeta.Email },
+    [exports.TextTypes.CustomURL]: { [exports.TextUIMetaKey]: exports.TextUIMeta.URL },
+};
+exports.TextUiMetaToTextType = {
+    [exports.TextUIMeta.Phone]: exports.TextTypes.CustomPhone,
+    [exports.TextUIMeta.Email]: exports.TextTypes.CustomEmail,
+    [exports.TextUIMeta.URL]: exports.TextTypes.CustomURL,
+};
+const getTextType = (fieldMeta) => exports.TextUiMetaToTextType[fieldMeta[exports.TextUIMetaKey]] || "fibery/text";
+exports.getTextType = getTextType;
+const getTextTypeLabel = (textType) => {
+    const labels = {
+        [exports.TextTypes.CustomPhone]: "Phone",
+        [exports.TextTypes.CustomEmail]: "Email",
+        [exports.TextTypes.CustomURL]: "URL",
+    };
+    return labels[textType] || "Text";
+};
+exports.getTextTypeLabel = getTextTypeLabel;

package/lib/src/field-utils/user-active.d.ts

@@ -0,0 +1,8 @@
+import { TypeObject } from "@fibery/schema";
+import { FieldExpression } from "@fibery/expression-utils";
+export declare const getIsUserActiveSelect: ({ typeObject, contextPath, }: {
+    typeObject: TypeObject;
+    contextPath?: FieldExpression;
+}) => {
+    [x: string]: (string | any[])[];
+} | null;

package/lib/src/field-utils/user-active.js

@@ -0,0 +1,28 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getIsUserActiveSelect = void 0;
+const memoize_1 = __importDefault(require("lodash/memoize"));
+const dynamic_keys_1 = require("../unit-utils/dynamic-keys");
+const getIsUserActiveQueryPredicate = (0, memoize_1.default)(({ typeObject, contextPath }) => {
+    if (typeObject.name !== "fibery/user") {
+        return null;
+    }
+    const pathToPrimitiveField = [...contextPath, "fibery/active?"];
+    const expression = ["=", pathToPrimitiveField, "$true"];
+    return {
+        // No sense in adding additional key to "makeDynamicKey" here.
+        // User active state is the same, regardless of contextPath we retrieve it with.
+        key: (0, dynamic_keys_1.makeDynamicKey)(dynamic_keys_1.isUserActiveDynamicKeyPrefix),
+        expression,
+    };
+}, ({ typeObject, contextPath }) => {
+    return `${typeObject.name}_${typeObject.version}_${contextPath.join(",")}`;
+});
+const getIsUserActiveSelect = ({ typeObject, contextPath = [], }) => {
+    const isUserActiveQueryPredicate = getIsUserActiveQueryPredicate({ typeObject, contextPath });
+    return isUserActiveQueryPredicate ? { [isUserActiveQueryPredicate.key]: isUserActiveQueryPredicate.expression } : null;
+};
+exports.getIsUserActiveSelect = getIsUserActiveSelect;

package/lib/src/field-utils/user-role.d.ts

@@ -0,0 +1,6 @@
+import { FieldObject } from "@fibery/schema";
+export declare const isUserRoleField: (fieldObject: FieldObject) => boolean;
+export declare const getUserRoleByKey: (roleKey: string) => {
+    key: string;
+    label: string;
+} | undefined;

package/lib/src/field-utils/user-role.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getUserRoleByKey = exports.isUserRoleField = void 0;
+const roles = [
+    {
+        key: "role/admin",
+        label: "Admin",
+    },
+    {
+        key: "role/member",
+        label: "Member",
+    },
+    {
+        key: "role/observer",
+        label: "Observer",
+    },
+    {
+        key: "role/guest",
+        label: "Guest",
+    },
+];
+const isUserRoleField = (fieldObject) => fieldObject.holderType === "fibery/user" && fieldObject.name === "fibery/role";
+exports.isUserRoleField = isUserRoleField;
+const getUserRoleByKey = (roleKey) => roles.find(({ key }) => key === roleKey);
+exports.getUserRoleByKey = getUserRoleByKey;

package/lib/src/field-utils/workflow.d.ts

@@ -0,0 +1,15 @@
+import { TypeObject } from "@fibery/schema";
+import { FieldExpression } from "@fibery/expression-utils";
+export declare function isWorkflowType(typeObject: TypeObject): boolean;
+export declare const getWorkflowFieldObject: (typeObject: TypeObject) => import("@fibery/schema").FieldObject | undefined;
+export declare const getIsFinalStateSelect: ({ typeObject, contextPath, }: {
+    typeObject: TypeObject;
+    contextPath?: FieldExpression;
+}) => {
+    [x: string]: (string | (string | import("@fibery/expression-utils").MultiFieldAccess)[])[];
+} | null;
+export declare function getWorkflowTypeSelect(typeObject: TypeObject): {
+    "workflow/Type": string[];
+} | {
+    "workflow/Type"?: undefined;
+};

package/lib/src/field-utils/workflow.js

@@ -0,0 +1,56 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getIsFinalStateSelect = exports.getWorkflowFieldObject = void 0;
+exports.isWorkflowType = isWorkflowType;
+exports.getWorkflowTypeSelect = getWorkflowTypeSelect;
+const memoize_1 = __importDefault(require("lodash/memoize"));
+const dynamic_keys_1 = require("../unit-utils/dynamic-keys");
+function isWorkflowType(typeObject) {
+    return typeObject.isEnum && typeObject.nameParts.namespace === "workflow";
+}
+const getWorkflowFieldObject = (typeObject) => {
+    const isWorkflowEnabledForType = typeObject.installedMixins.has("workflow/workflow");
+    let workflowFieldObject;
+    if (isWorkflowEnabledForType) {
+        workflowFieldObject = typeObject.fieldObjects.find((fieldObject) => {
+            if (fieldObject.nameParts.namespace === "workflow") {
+                return fieldObject.typeObject.fieldObjects.find((x) => x.name === "workflow/Final");
+            }
+            return false;
+        });
+    }
+    return workflowFieldObject;
+};
+exports.getWorkflowFieldObject = getWorkflowFieldObject;
+const getIsFinalStateQueryPredicate = (0, memoize_1.default)(({ typeObject, contextPath }) => {
+    const workflowFieldObject = (0, exports.getWorkflowFieldObject)(typeObject);
+    if (workflowFieldObject) {
+        const pathToFinal = [...contextPath, workflowFieldObject.name, "workflow/Final"];
+        const expression = ["=", pathToFinal, "$true"];
+        return {
+            key: (0, dynamic_keys_1.makeDynamicKey)(dynamic_keys_1.isFinalStateDynamicKeyPrefix),
+            expression,
+        };
+    }
+    else {
+        return null;
+    }
+}, ({ typeObject, contextPath }) => {
+    return `${typeObject.name}_${typeObject.version}_${contextPath.join(",")}`;
+});
+const getIsFinalStateSelect = ({ typeObject, contextPath = [], }) => {
+    const isFinalStateQueryPredicate = getIsFinalStateQueryPredicate({ typeObject, contextPath });
+    return isFinalStateQueryPredicate ? { [isFinalStateQueryPredicate.key]: isFinalStateQueryPredicate.expression } : null;
+};
+exports.getIsFinalStateSelect = getIsFinalStateSelect;
+function getWorkflowTypeSelect(typeObject) {
+    if (isWorkflowType(typeObject)) {
+        return {
+            "workflow/Type": ["workflow/Type"],
+        };
+    }
+    return {};
+}

package/lib/src/index.d.ts

@@ -0,0 +1,16 @@
+export function deleteExpressionWithNotFoundFieldsOrTypesInView(schema: any, view: any, ensureAxisInvariant?: boolean): any;
+export function fixUserSelectedUnits(schema: any, view: any, { unitDefinitions, getDefaultUnitTypeForField }: {
+    unitDefinitions: any;
+    getDefaultUnitTypeForField: any;
+}): any;
+export function fixContextExpressionWithBrokenPath(schema: any, view: any, defaultContextExpression: any): any;
+export function collectGarbage(schema: any, view: any): any;
+export function replaceNamesWithIdsInView(schema: any, view: any): any;
+export function replaceIdsWithNamesInView(schema: any, view: any): any;
+export function getViewCardTypes({ "fibery/meta": { items } }: {
+    "fibery/meta": {
+        items: any;
+    };
+}): any;
+export function migrateHideWhenEmptyToUnitsLevel(view: any): any;
+export { deleteExpressionWithNotFoundFieldsOrTypesInSmartFolder, replaceIdsWithNamesInSmartFolder, replaceNamesWithIdsInSmartFolder } from "./private/smart-folder";

package/lib/src/index.js

@@ -0,0 +1,258 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.migrateHideWhenEmptyToUnitsLevel = exports.getViewCardTypes = exports.replaceIdsWithNamesInView = exports.replaceNamesWithIdsInView = exports.collectGarbage = exports.fixContextExpressionWithBrokenPath = exports.fixUserSelectedUnits = exports.deleteExpressionWithNotFoundFieldsOrTypesInView = exports.replaceNamesWithIdsInSmartFolder = exports.replaceIdsWithNamesInSmartFolder = exports.deleteExpressionWithNotFoundFieldsOrTypesInSmartFolder = void 0;
+const immutability_helper_1 = __importDefault(require("immutability-helper"));
+const get_1 = __importDefault(require("lodash/get"));
+const omit_1 = __importDefault(require("lodash/omit"));
+const board = __importStar(require("./private/board"));
+const calendar = __importStar(require("./private/calendar"));
+const feed = __importStar(require("./private/feed"));
+const form = __importStar(require("./private/form"));
+const map = __importStar(require("./private/map"));
+const smartfolder = __importStar(require("./private/smart-folder"));
+const timeline = __importStar(require("./private/timeline"));
+const utils_1 = require("./private/utils");
+var smart_folder_1 = require("./private/smart-folder");
+Object.defineProperty(exports, "deleteExpressionWithNotFoundFieldsOrTypesInSmartFolder", { enumerable: true, get: function () { return smart_folder_1.deleteExpressionWithNotFoundFieldsOrTypesInSmartFolder; } });
+Object.defineProperty(exports, "replaceIdsWithNamesInSmartFolder", { enumerable: true, get: function () { return smart_folder_1.replaceIdsWithNamesInSmartFolder; } });
+Object.defineProperty(exports, "replaceNamesWithIdsInSmartFolder", { enumerable: true, get: function () { return smart_folder_1.replaceNamesWithIdsInSmartFolder; } });
+const deleteExpressionWithNotFoundFieldsOrTypesInView = (schema, view, ensureAxisInvariant = true) => {
+    switch (view["fibery/type"]) {
+        case "board":
+        case "gallery":
+            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;
+    }
+};
+exports.deleteExpressionWithNotFoundFieldsOrTypesInView = deleteExpressionWithNotFoundFieldsOrTypesInView;
+const fixUserSelectedUnits = (schema, view, { unitDefinitions, getDefaultUnitTypeForField }) => {
+    switch (view["fibery/type"]) {
+        case "board":
+        case "gallery":
+            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;
+    }
+};
+exports.fixUserSelectedUnits = fixUserSelectedUnits;
+const fixContextExpressionWithBrokenPath = (schema, view, defaultContextExpression) => {
+    switch (view["fibery/type"]) {
+        case "board":
+        case "gallery":
+            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;
+    }
+};
+exports.fixContextExpressionWithBrokenPath = fixContextExpressionWithBrokenPath;
+/**
+ * Removes garbage from view's meta to reduce the size.
+ */
+const collectGarbage = (schema, view) => {
+    const deleteRemoved = (x) => {
+        if (Array.isArray(x)) {
+            return x.map(deleteRemoved).filter((y) => y !== utils_1.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] !== utils_1.REMOVE);
+            return Object.fromEntries(tmp);
+        }
+        return x;
+    };
+    switch (view["fibery/type"]) {
+        case "board":
+        case "gallery":
+            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;
+    }
+};
+exports.collectGarbage = collectGarbage;
+const replaceNamesWithIdsInView = (schema, view) => {
+    switch (view["fibery/type"]) {
+        case "board":
+        case "gallery":
+            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;
+    }
+};
+exports.replaceNamesWithIdsInView = replaceNamesWithIdsInView;
+const replaceIdsWithNamesInView = (schema, view) => {
+    switch (view["fibery/type"]) {
+        case "board":
+        case "gallery":
+            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;
+    }
+};
+exports.replaceIdsWithNamesInView = replaceIdsWithNamesInView;
+const getViewCardTypes = ({ "fibery/meta": { items } }) => items.map(({ query: { "q/from": type } }) => type);
+exports.getViewCardTypes = getViewCardTypes;
+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 = (0, get_1.default)(view, ["fibery/meta", "showEmptyUnitValues"]);
+    if (showEmptyUnitValues === undefined) {
+        return view;
+    }
+    let result = (0, immutability_helper_1.default)(view, {
+        "fibery/meta": {
+            $apply: (x) => (0, omit_1.default)(x, "showEmptyUnitValues"),
+        },
+    });
+    if (showEmptyUnitValues === true) {
+        return result;
+    }
+    switch (result["fibery/type"]) {
+        case "board":
+        case "gallery":
+            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;
+    }
+};
+exports.migrateHideWhenEmptyToUnitsLevel = migrateHideWhenEmptyToUnitsLevel;

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

@@ -0,0 +1,11 @@
+export function replaceIdsWithNamesInBoardView(schema: any, view: any): any;
+export function replaceNamesWithIdsInBoardView(schema: any, view: any): any;
+export function deleteExpressionWithNotFoundOrInvalidFieldsOrTypesInBoardView(schema: any, view: any, ensureAxisInvariant?: boolean): any;
+export function fixUserSelectedUnitsInBoardView(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 enableHideWhenEmptyForCovers(view: any): any;
+export function enableHideWhenEmptyForCheckedEditableUnits(view: any): any;