@fibery/views 17.0.4 → 18.0.2

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

@@ -0,0 +1,10 @@
+export function replaceNamesWithIdsInTimelineView(schema: any, view: any): any;
+export function replaceIdsWithNamesInTimelineView(schema: any, view: any): any;
+export function deleteExpressionWithNotFoundFieldsOrTypesInTimelineView(schema: any, view: any, ensureAxisInvariant: any, canGroupMetaItem?: (metaItem: any) => boolean): any;
+export function fixUserSelectedUnitsInTimelineView(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 enableHideWhenEmptyForCheckedEditableUnits(view: any): any;

package/lib/src/private/timeline.js

@@ -0,0 +1,323 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.enableHideWhenEmptyForCheckedEditableUnits = exports.collectGarbage = exports.fixContextExpressionWithBrokenPath = exports.fixUserSelectedUnitsInTimelineView = exports.deleteExpressionWithNotFoundFieldsOrTypesInTimelineView = exports.replaceIdsWithNamesInTimelineView = exports.replaceNamesWithIdsInTimelineView = void 0;
+const immutability_helper_1 = __importDefault(require("immutability-helper"));
+const entries_1 = __importDefault(require("lodash/entries"));
+const first_1 = __importDefault(require("lodash/first"));
+const get_1 = __importDefault(require("lodash/get"));
+const has_1 = __importDefault(require("lodash/has"));
+const isEmpty_1 = __importDefault(require("lodash/isEmpty"));
+const set_1 = __importDefault(require("lodash/set"));
+const some_1 = __importDefault(require("lodash/some"));
+const smart_folder_1 = require("./smart-folder");
+const units_1 = require("./units");
+const utils_1 = require("./utils");
+const visitAxisSingle = (axis, visitor) => {
+    const fromType = (0, get_1.default)(axis, ["query", "q/from"]);
+    const firstOrNull = (x) => (0, first_1.default)(x) || null;
+    const axisResult = {
+        ...axis,
+        filter: axis.filter ? visitor.visitFilter(fromType, axis.filter) : null,
+        query: axis.query && visitor.visitQueryExpression(axis.query),
+        contextExpression: (0, utils_1.visitContextExpression)(fromType, axis.contextExpression, visitor),
+        units: axis.units &&
+            axis.units
+                .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),
+        groupByExpression: axis.groupByExpression && firstOrNull(visitor.visitExpression(fromType, [axis.groupByExpression])),
+    };
+    if (!axisResult.query) {
+        return null;
+    }
+    if (!axisResult.units) {
+        delete axisResult.units;
+    }
+    return axisResult;
+};
+const visitAxis = (axis, visitor) => {
+    if (axis && Object.hasOwn(axis, "query")) {
+        return visitAxisSingle(axis, visitor);
+    }
+    if (axis && Object.hasOwn(axis, "enums")) {
+        const axisNew = (0, immutability_helper_1.default)(axis, {
+            enums: {
+                $apply: (enums) => visitor.visitEnums(enums),
+            },
+        });
+        const { enums } = axisNew;
+        return enums ? axisNew : null;
+    }
+    return axis;
+};
+const visitView = (view, visitor) => (0, immutability_helper_1.default)(view, {
+    "fibery/meta": {
+        y: {
+            $apply: (y) => visitAxis(y, visitor),
+        },
+        items: {
+            $apply: (items) => {
+                const removedItemsIndexes = items
+                    .map((item, index) => (visitor.visitQueryExpression(item.query) ? null : index))
+                    .filter((value) => value !== null);
+                return items
+                    .map((item) => {
+                    const fromType = (0, get_1.default)(item, ["query", "q/from"]);
+                    const hasGroupingExpression = (0, has_1.default)(item, ["groupingExpression"]);
+                    return fromType
+                        ? (0, immutability_helper_1.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,
+                            },
+                            secondaryStartExpression: {
+                                $apply: (secondaryStartExpression) => secondaryStartExpression
+                                    ? visitor.visitExpression(fromType, secondaryStartExpression)
+                                    : secondaryStartExpression,
+                            },
+                            secondaryEndExpression: {
+                                $apply: (secondaryEndExpression) => secondaryEndExpression
+                                    ? visitor.visitExpression(fromType, secondaryEndExpression)
+                                    : secondaryEndExpression,
+                            },
+                            contextExpression: {
+                                $apply: (contextExpression) => (0, utils_1.visitContextExpression)(fromType, contextExpression, visitor),
+                            },
+                            filter: {
+                                $apply: (filter) => (filter ? visitor.visitFilter(fromType, filter) : null),
+                            },
+                            query: {
+                                $apply: (query) => (query ? visitor.visitQueryExpression(query) : 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));
+                                },
+                            },
+                            dependencyExpression: {
+                                $apply: (expression) => {
+                                    return expression && visitor.visitExpression(fromType, expression);
+                                },
+                            },
+                            groupBy: {
+                                $apply: (groupBy) => {
+                                    if (!groupBy) {
+                                        return groupBy;
+                                    }
+                                    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);
+                                },
+                            },
+                            ...(hasGroupingExpression
+                                ? {
+                                    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);
+                                        },
+                                    },
+                                }
+                                : undefined),
+                        })
+                        : item;
+                })
+                    .filter((item) => {
+                    const { query } = item;
+                    return query ? item : null;
+                });
+            },
+        },
+        milestones: {
+            $apply: (milestones) => {
+                if (!milestones) {
+                    return milestones;
+                }
+                return milestones
+                    .map((item) => {
+                    const fromType = (0, get_1.default)(item, ["query", "q/from"]);
+                    return fromType
+                        ? (0, immutability_helper_1.default)(item, {
+                            dateExpression: {
+                                $apply: (startExpression) => startExpression ? visitor.visitExpression(fromType, startExpression) : startExpression,
+                            },
+                            filter: {
+                                $apply: (filter) => (filter ? visitor.visitFilter(fromType, filter) : null),
+                            },
+                            query: {
+                                $apply: (query) => (query ? visitor.visitQueryExpression(query) : null),
+                            },
+                            contextExpression: {
+                                $apply: (contextExpression) => (0, utils_1.visitContextExpression)(fromType, contextExpression, visitor),
+                            },
+                        })
+                        : item;
+                })
+                    .filter((item) => {
+                    const { query } = item;
+                    return query ? item : null;
+                });
+            },
+        },
+    },
+});
+const replaceNamesWithIdsInTimelineView = (schema, view) => {
+    const visitor = {
+        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),
+        visitEnums: (enums) => (0, entries_1.default)(enums).reduce((result, [type, axis]) => {
+            if (Object.hasOwn(schema.typeObjectsByName, type)) {
+                const typeObject = schema.typeObjectsByName[type];
+                result[typeObject.id] = visitAxisSingle(axis, visitor);
+            }
+            else {
+                result[type] = axis;
+            }
+            return result;
+        }, {}),
+        visitGroupByExpression: (groupBy, fromType) => (0, smart_folder_1.replaceNamesWithIdsInGroupByExpression)(schema, groupBy, fromType),
+    };
+    return visitView(view, visitor);
+};
+exports.replaceNamesWithIdsInTimelineView = replaceNamesWithIdsInTimelineView;
+const replaceIdsWithNamesInTimelineView = (schema, view) => {
+    const visitor = {
+        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),
+        visitEnums: (enums) => (0, entries_1.default)(enums).reduce((result, [typeId, axis]) => {
+            if (Object.hasOwn(schema.typeObjectsById, typeId)) {
+                const typeObject = schema.typeObjectsById[typeId];
+                result[typeObject.name] = visitAxisSingle(axis, visitor);
+            }
+            else {
+                result[typeId] = axis;
+            }
+            return result;
+        }, {}),
+        visitGroupByExpression: (groupBy, fromType) => (0, smart_folder_1.replaceIdsWithNamesInGroupByExpression)(schema, groupBy, fromType),
+    };
+    return visitView(view, visitor);
+};
+exports.replaceIdsWithNamesInTimelineView = replaceIdsWithNamesInTimelineView;
+const ensureAxisAndItemExpressionInvariant = (view, canGroupMetaItem) => {
+    const actions = [];
+    const y = (0, get_1.default)(view, ["fibery/meta", "y"]);
+    const yQuery = (0, get_1.default)(view, ["fibery/meta", "y", "query"]);
+    const yGroupByExpression = (0, get_1.default)(view, ["fibery/meta", "y", "groupByExpression"]);
+    const items = (0, get_1.default)(view, ["fibery/meta", "items"]);
+    if (yQuery === null && yGroupByExpression !== null) {
+        actions.push(() => (0, set_1.default)(view, ["fibery/meta", "y", "groupByExpression"], null));
+    }
+    if (y === null) {
+        const resetActions = items.map((item) => () => (item.yExpression = null));
+        actions.push(...resetActions);
+    }
+    const filteredMetaItems = items.filter(canGroupMetaItem);
+    if (y !== null && (0, some_1.default)(filteredMetaItems, ({ yExpression }) => yExpression === null)) {
+        const resetActions = filteredMetaItems.map((item) => () => (item.yExpression = null));
+        actions.push(...resetActions);
+        actions.push(() => (0, set_1.default)(view, ["fibery/meta", "y"], null));
+    }
+    if (y !== null && (0, isEmpty_1.default)(items)) {
+        actions.push(() => (0, set_1.default)(view, ["fibery/meta", "y"], null));
+    }
+    actions.forEach((action) => action());
+    return view;
+};
+const deleteExpressionWithNotFoundFieldsOrTypesInTimelineView = (schema, view, ensureAxisInvariant, canGroupMetaItem = (metaItem) => true) => {
+    const visitor = {
+        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),
+        visitEnums: (enums) => {
+            const enumsNew = (0, entries_1.default)(enums).reduce((result, [type, axis]) => {
+                if (Object.hasOwn(schema.typeObjectsByName, type)) {
+                    const typeObject = schema.typeObjectsByName[type];
+                    const axisResult = visitAxisSingle(axis, visitor);
+                    if (axisResult) {
+                        result[typeObject.name] = axisResult;
+                    }
+                }
+                return result;
+            }, {});
+            return (0, isEmpty_1.default)(enumsNew) ? null : enumsNew;
+        },
+        visitGroupByExpression: (groupBy, fromType, removedItems) => (0, smart_folder_1.deleteExpressionWithNotFoundFieldsOrTypesInGroupByExpression)(schema, groupBy, fromType, removedItems),
+    };
+    const viewNew = visitView(view, visitor);
+    return ensureAxisInvariant ? ensureAxisAndItemExpressionInvariant(viewNew, canGroupMetaItem) : viewNew;
+};
+exports.deleteExpressionWithNotFoundFieldsOrTypesInTimelineView = deleteExpressionWithNotFoundFieldsOrTypesInTimelineView;
+const fixUserSelectedUnitsInTimelineView = (schema, view, { unitDefinitions, getDefaultUnitTypeForField }) => {
+    return visitView(view, {
+        visitQueryExpression: (query) => query,
+        visitExpression: (_fromType, expression) => expression,
+        visitFilter: (_fromType, filter) => filter,
+        visitViewUnit: (fromType, unit, units) => (0, units_1.fixViewUnit)(schema, fromType, unit, units, { unitDefinitions, getDefaultUnitTypeForField }),
+        visitEnums: (enums) => enums,
+        visitGroupByExpression: (groupBy) => groupBy,
+    });
+};
+exports.fixUserSelectedUnitsInTimelineView = fixUserSelectedUnitsInTimelineView;
+const fixContextExpressionWithBrokenPath = (schema, view, defaultContextExpression) => visitView(view, {
+    visitExpression: (_fromType, expression) => expression,
+    visitFilter: (_fromType, filter) => filter,
+    visitQueryExpression: (query) => query,
+    visitContextExpression: (fromType, expression) => (0, utils_1.resetContextExpressionIfBroken)(schema, fromType, expression, defaultContextExpression),
+    visitEnums: (enums) => enums,
+    visitGroupByExpression: (groupBy) => groupBy,
+});
+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),
+        visitEnums: (enums) => enums,
+        visitGroupByExpression: (groupBy) => groupBy,
+    });
+};
+exports.collectGarbage = collectGarbage;
+const enableHideWhenEmptyForCheckedEditableUnits = (view) => {
+    return visitView(view, {
+        visitQueryExpression: (queryExpression) => queryExpression,
+        visitExpression: (_fromType, expression) => expression,
+        visitFilter: (_fromType, filter) => filter,
+        visitViewUnit: (_fromType, unit) => (0, units_1.enableHideWhenEmptyForCheckedEditableUnit)(unit),
+        visitEnums: (enums) => enums,
+        visitGroupByExpression: (groupBy) => groupBy,
+    });
+};
+exports.enableHideWhenEmptyForCheckedEditableUnits = enableHideWhenEmptyForCheckedEditableUnits;

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

@@ -0,0 +1,6 @@
+export function fixViewUnit(schema: any, fromType: any, unit: any, units: any, { unitDefinitions, getDefaultUnitTypeForField, migrateFileCollectionUnit }: {
+    unitDefinitions: any;
+    getDefaultUnitTypeForField: any;
+    migrateFileCollectionUnit?: boolean | undefined;
+}): any;
+export function enableHideWhenEmptyForCheckedEditableUnit(unit: any): any;

package/lib/src/private/units.js

@@ -0,0 +1,144 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.enableHideWhenEmptyForCheckedEditableUnit = exports.fixViewUnit = void 0;
+const utils_1 = require("./utils");
+const getField = (schema, fromType, field) => Object.hasOwn(schema.typeObjectsByName, fromType) &&
+    Object.hasOwn(schema.typeObjectsByName[fromType].fieldObjectsByName, field)
+    ? schema.typeObjectsByName[fromType].fieldObjectsByName[field]
+    : undefined;
+const getFieldType = (schema, fromType, field) => getField(schema, fromType, field)?.type;
+const getFieldMeta = (schema, fromType, field) => getField(schema, fromType, 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 getUnitKind = (unit) => {
+    if (unit.type === "user-button") {
+        return "user-button";
+    }
+    if (["type-icon", "type-badge", "type-badge-abbr"].includes(unit.type)) {
+        return "db";
+    }
+    return "field";
+};
+const migrateUnitOptsDefault = {
+    migrateFileCollectionUnit: true,
+};
+const migrateUnit = (schema, fromType, unit, units, opts = migrateUnitOptsDefault) => {
+    const { type, expression } = unit;
+    const kind = unit.kind || getUnitKind(unit);
+    if (type === "date-time") {
+        return {
+            ...unit,
+            kind,
+            type: "date",
+        };
+    }
+    if (type === "date-time-range") {
+        return {
+            ...unit,
+            kind,
+            type: "date-range",
+        };
+    }
+    if (type === "text") {
+        const [field] = expression;
+        const fieldType = getFieldType(schema, fromType, field);
+        if (fieldType === "fibery/email") {
+            return {
+                ...unit,
+                kind,
+                type: "email",
+            };
+        }
+    }
+    if (["text", "email", "phone", "url"].includes(type)) {
+        const [field] = expression;
+        if (getFieldType(schema, fromType, field) === "fibery/text") {
+            return {
+                ...unit,
+                kind,
+                type: getUnitTypeForTextField(getFieldMeta(schema, fromType, field)),
+            };
+        }
+    }
+    if (type === "files-collection") {
+        const [field] = expression;
+        if (getFieldType(schema, fromType, field) === "fibery/file") {
+            return {
+                ...unit,
+                kind,
+                type: opts.migrateFileCollectionUnit ? "file-collection-count" : "collection-count",
+            };
+        }
+    }
+    if (type === "avatar" && !expression) {
+        const isAvatarExntensionEnabled = schema.typeObjectsByName[fromType]?.installedMixins.has("avatar/avatar-mixin");
+        const hasAvatarExntensionField = getFieldType(schema, fromType, "avatar/avatars") === "fibery/file";
+        if (isAvatarExntensionEnabled && hasAvatarExntensionField) {
+            return {
+                ...unit,
+                expression: ["avatar/avatars"],
+                kind,
+            };
+        }
+    }
+    if (opts.migrateFileCollectionUnit && type === "collection-count") {
+        const [field] = expression;
+        const fieldObject = getField(schema, fromType, field);
+        if (fieldObject?.type === "fibery/file" && fieldObject?.isCollection) {
+            return {
+                ...unit,
+                kind,
+                type: "file-collection-count",
+            };
+        }
+    }
+    return { ...unit, kind };
+};
+const fixViewUnit = (schema, fromType, unit, units, { unitDefinitions, getDefaultUnitTypeForField, migrateFileCollectionUnit = true }) => {
+    const migrated = migrateUnit(schema, fromType, unit, units, { migrateFileCollectionUnit });
+    const field = unit.expression?.[0];
+    const fieldObject = getField(schema, fromType, field);
+    if (fieldObject) {
+        const allowedUnits = unitDefinitions.getUnitsForField(fieldObject);
+        if (allowedUnits.some((u) => u.type === migrated.type)) {
+            return migrated;
+        }
+        else {
+            if (unit.checked) {
+                const otherUnitsForField = units.filter((u) => u !== unit && u.expression && u.expression[0] === field);
+                const hasEnabledUnitForField = otherUnitsForField.some((u) => u.checked);
+                if (hasEnabledUnitForField) {
+                    return utils_1.REMOVE;
+                }
+                const defaultUnitType = getDefaultUnitTypeForField(fieldObject, allowedUnits);
+                const defaultUnit = (defaultUnitType && otherUnitsForField.find((u) => u.type === defaultUnitType)) || otherUnitsForField[0];
+                if (defaultUnit) {
+                    defaultUnit.checked = true;
+                    return utils_1.REMOVE;
+                }
+            }
+            else {
+                return utils_1.REMOVE;
+            }
+        }
+    }
+    return migrated;
+};
+exports.fixViewUnit = fixViewUnit;
+const enableHideWhenEmptyForCheckedEditableUnit = (unit) => {
+    if (unit.checked) {
+        return { ...unit, hideWhenEmpty: true };
+    }
+    return unit;
+};
+exports.enableHideWhenEmptyForCheckedEditableUnit = enableHideWhenEmptyForCheckedEditableUnit;

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

@@ -0,0 +1,17 @@
+export const REMOVE: unique symbol;
+export function deleteExpressionWithNotFoundFieldsOrTypesInFilter(schema: any, fromType: any, filter: any): any;
+export function deleteExpressionWithNotFoundFieldsOrTypesInQueryExpression(schema: any, queryExpression: any): Partial<any> | null;
+export function replaceNamesWithIdsInExpression(schema: any, fromType: any, expression: any): any;
+export function replaceIdsWithNamesInExpression(schema: any, fromTypeId: any, expression: any): any;
+export function visitViewUnit(fromType: any, unit: any, visitor: any): any;
+export function visitContextExpression(fromType: any, contextExpression: any, visitor: any): any;
+export function replaceIdsWithNamesInQueryExpression(schema: any, queryExpression: any): any;
+export function replaceIdsWithNamesInFilter(schema: any, fromType: any, filter: any): any;
+export function replaceNamesWithIdsInFilter(schema: any, fromType: any, filter: any): any;
+export function replaceNamesWithIdsInQueryExpression(schema: any, queryExpression: any): any;
+export function deleteExpressionWithNotFoundFieldsOrTypesInExpression(schema: any, fromType: any, expression: any): any;
+export function resetContextExpressionIfBroken(schema: any, fromType: any, expression: any, defaultExpression: any): any;
+export function isUnitExpressionValid(unit: any): boolean;
+export function getFieldObjectsById(smartFolder: any, schema: any): any;
+export function replaceIdsWithNamesInUnitGroupKey(unitGroupKey: any, fieldObjectsById: any): any;
+export function replaceNamesWithIdsInUnitGroupKey(unitGroupKey: any, schema: any): any;