@fibery/views 17.0.4 → 18.0.2

package/lib/src/private/utils.js

@@ -0,0 +1,267 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.replaceNamesWithIdsInUnitGroupKey = exports.replaceIdsWithNamesInUnitGroupKey = exports.getFieldObjectsById = exports.isUnitExpressionValid = exports.resetContextExpressionIfBroken = exports.deleteExpressionWithNotFoundFieldsOrTypesInExpression = exports.replaceNamesWithIdsInQueryExpression = exports.replaceNamesWithIdsInFilter = exports.replaceIdsWithNamesInFilter = exports.replaceIdsWithNamesInQueryExpression = exports.visitContextExpression = exports.visitViewUnit = exports.replaceIdsWithNamesInExpression = exports.replaceNamesWithIdsInExpression = exports.deleteExpressionWithNotFoundFieldsOrTypesInQueryExpression = exports.deleteExpressionWithNotFoundFieldsOrTypesInFilter = exports.REMOVE = void 0;
+const visitors_1 = require("@fibery/expression-utils/src/visitors");
+const pickBy_1 = __importDefault(require("lodash/pickBy"));
+// Return this symbol from a visitor callback to remove the node from the
+// output. Not supported in all places, add support as needed.
+exports.REMOVE = Symbol("remove");
+function visitDeleteExpressionInFilterGroup(filter, visitExpression) {
+    if (filter.kind !== "group") {
+        return null;
+    }
+    const value = filter.value
+        .map((nestedFilter) => {
+        if (nestedFilter.kind === "group") {
+            return visitFilterGroup(nestedFilter, visitExpression);
+        }
+        const expression = nestedFilter.value.expression ? visitExpression(nestedFilter.value.expression) : null;
+        if (!expression) {
+            return null;
+        }
+        return {
+            ...nestedFilter,
+            value: {
+                ...nestedFilter.value,
+                expression: expression,
+            },
+        };
+    })
+        .filter(Boolean);
+    if (value.length === 0) {
+        return null;
+    }
+    return {
+        ...filter,
+        value: value,
+    };
+}
+const deleteExpressionWithNotFoundFieldsOrTypesInFilter = (schema, fromType, filter) => {
+    return visitDeleteExpressionInFilterGroup(filter, (expression) => (0, exports.deleteExpressionWithNotFoundFieldsOrTypesInExpression)(schema, fromType, expression));
+};
+exports.deleteExpressionWithNotFoundFieldsOrTypesInFilter = deleteExpressionWithNotFoundFieldsOrTypesInFilter;
+const deleteExpressionWithNotFoundFieldsOrTypesInQueryExpression = (schema, queryExpression) => {
+    const { "q/from": fromExpression, "q/where": whereExpression, "q/order-by": orderByExpression } = queryExpression;
+    if (Object.hasOwn(schema.typeObjectsByName, fromExpression)) {
+        const typeObject = schema.typeObjectsByName[fromExpression];
+        return (0, pickBy_1.default)({
+            ...queryExpression,
+            ...(whereExpression
+                ? {
+                    "q/where": (0, visitors_1.deleteExpressionsWithNotFoundFieldsVisitor)(typeObject).visitExpression(whereExpression),
+                }
+                : null),
+            ...(orderByExpression
+                ? {
+                    "q/order-by": (0, visitors_1.deleteExpressionsWithNotFoundFieldsVisitor)(typeObject).visitOrderByExpression(orderByExpression),
+                }
+                : null),
+        });
+    }
+    return null;
+};
+exports.deleteExpressionWithNotFoundFieldsOrTypesInQueryExpression = deleteExpressionWithNotFoundFieldsOrTypesInQueryExpression;
+const replaceNamesWithIdsInExpression = (schema, fromType, expression) => {
+    if (Object.hasOwn(schema.typeObjectsByName, fromType)) {
+        const typeObject = schema.typeObjectsByName[fromType];
+        return (0, visitors_1.replaceNamesWithIdsVisitor)(typeObject).visitExpression(expression);
+    }
+    return expression;
+};
+exports.replaceNamesWithIdsInExpression = replaceNamesWithIdsInExpression;
+const replaceIdsWithNamesInExpression = (schema, fromTypeId, expression) => {
+    if (Object.hasOwn(schema.typeObjectsById, fromTypeId)) {
+        const typeObject = schema.typeObjectsById[fromTypeId];
+        return (0, visitors_1.replaceIdsWithNamesVisitor)(typeObject).visitExpression(expression);
+    }
+    return expression;
+};
+exports.replaceIdsWithNamesInExpression = replaceIdsWithNamesInExpression;
+const visitViewUnit = (fromType, unit, visitor) => {
+    const { expression } = unit;
+    if (expression) {
+        return {
+            ...unit,
+            ...{
+                expression: visitor.visitExpression(fromType, expression),
+            },
+        };
+    }
+    return unit;
+};
+exports.visitViewUnit = visitViewUnit;
+const visitContextExpression = (fromType, contextExpression, visitor) => {
+    const visitContextExpression = visitor.visitContextExpression
+        ? visitor.visitContextExpression
+        : visitor.visitExpression;
+    return contextExpression ? visitContextExpression(fromType, contextExpression) : contextExpression;
+};
+exports.visitContextExpression = visitContextExpression;
+const replaceIdsWithNamesInQueryExpression = (schema, queryExpression) => {
+    const { "q/from": fromExpression, "q/where": whereExpression, "q/order-by": orderByExpression } = queryExpression;
+    if (Object.hasOwn(schema.typeObjectsById, fromExpression)) {
+        const typeObject = schema.typeObjectsById[fromExpression];
+        return {
+            ...queryExpression,
+            ...{ "q/from": typeObject.name },
+            ...(whereExpression
+                ? {
+                    "q/where": (0, visitors_1.replaceIdsWithNamesVisitor)(typeObject).visitExpression(whereExpression),
+                }
+                : null),
+            ...(orderByExpression
+                ? {
+                    "q/order-by": (0, visitors_1.replaceIdsWithNamesVisitor)(typeObject).visitOrderByExpression(orderByExpression),
+                }
+                : null),
+        };
+    }
+    return queryExpression;
+};
+exports.replaceIdsWithNamesInQueryExpression = replaceIdsWithNamesInQueryExpression;
+function visitFilterGroup(filter, visitExpression, type) {
+    if (filter.kind !== "group") {
+        return null;
+    }
+    return {
+        ...filter,
+        value: filter.value.map((nestedFilter) => {
+            if (nestedFilter.kind === "group") {
+                return visitFilterGroup(nestedFilter, visitExpression);
+            }
+            return {
+                ...nestedFilter,
+                value: {
+                    ...nestedFilter.value,
+                    expression: nestedFilter.value.expression ? visitExpression(nestedFilter.value.expression) : null,
+                },
+            };
+        }),
+    };
+}
+const replaceIdsWithNamesInFilter = (schema, fromType, filter) => {
+    if (Object.hasOwn(schema.typeObjectsById, fromType)) {
+        const typeObject = schema.typeObjectsById[fromType];
+        return filter
+            ? visitFilterGroup(filter, (expression) => (0, visitors_1.replaceIdsWithNamesVisitor)(typeObject).visitExpression(expression), "ids")
+            : null;
+    }
+    return filter;
+};
+exports.replaceIdsWithNamesInFilter = replaceIdsWithNamesInFilter;
+const replaceNamesWithIdsInFilter = (schema, fromType, filter) => {
+    if (Object.hasOwn(schema.typeObjectsByName, fromType)) {
+        const typeObject = schema.typeObjectsByName[fromType];
+        return filter
+            ? visitFilterGroup(filter, (expression) => (0, visitors_1.replaceNamesWithIdsVisitor)(typeObject).visitExpression(expression), "names")
+            : null;
+    }
+    return filter;
+};
+exports.replaceNamesWithIdsInFilter = replaceNamesWithIdsInFilter;
+const replaceNamesWithIdsInQueryExpression = (schema, queryExpression) => {
+    const { "q/from": fromExpression, "q/where": whereExpression, "q/order-by": orderByExpression } = queryExpression;
+    if (Object.hasOwn(schema.typeObjectsByName, fromExpression)) {
+        const typeObject = schema.typeObjectsByName[fromExpression];
+        return {
+            ...queryExpression,
+            ...{ "q/from": typeObject.id },
+            ...(whereExpression
+                ? {
+                    "q/where": (0, visitors_1.replaceNamesWithIdsVisitor)(typeObject).visitExpression(whereExpression),
+                }
+                : null),
+            ...(orderByExpression
+                ? {
+                    "q/order-by": (0, visitors_1.replaceNamesWithIdsVisitor)(typeObject).visitOrderByExpression(orderByExpression),
+                }
+                : null),
+        };
+    }
+    return queryExpression;
+};
+exports.replaceNamesWithIdsInQueryExpression = replaceNamesWithIdsInQueryExpression;
+const deleteExpressionWithNotFoundFieldsOrTypesInExpression = (schema, fromType, expression) => {
+    if (Object.hasOwn(schema.typeObjectsByName, fromType)) {
+        const typeObject = schema.typeObjectsByName[fromType];
+        return (0, visitors_1.deleteExpressionsWithNotFoundFieldsVisitor)(typeObject).visitExpression(expression);
+    }
+    return null;
+};
+exports.deleteExpressionWithNotFoundFieldsOrTypesInExpression = deleteExpressionWithNotFoundFieldsOrTypesInExpression;
+const resetContextExpressionIfBroken = (schema, fromType, expression, defaultExpression) => (0, exports.deleteExpressionWithNotFoundFieldsOrTypesInExpression)(schema, fromType, expression) || defaultExpression;
+exports.resetContextExpressionIfBroken = resetContextExpressionIfBroken;
+const isUnitExpressionValid = (unit) => {
+    if (Object.hasOwn(unit, "expression")) {
+        const { expression } = unit;
+        return expression !== null;
+    }
+    return true;
+};
+exports.isUnitExpressionValid = isUnitExpressionValid;
+const getFieldObjectsById = (smartFolder, schema) => {
+    const types = smartFolder["fibery/meta"].items.map((item) => item.query["q/from"]);
+    return types.reduce((acc, type) => {
+        if (!Object.hasOwn(schema.typeObjectsById, type)) {
+            return acc;
+        }
+        const fieldObjects = schema.typeObjectsById[type].fieldObjectsById;
+        return { ...acc, ...fieldObjects };
+    }, {});
+};
+exports.getFieldObjectsById = getFieldObjectsById;
+const replaceIdsWithNamesInUnitGroupKey = (unitGroupKey, fieldObjectsById) => {
+    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("|");
+};
+exports.replaceIdsWithNamesInUnitGroupKey = replaceIdsWithNamesInUnitGroupKey;
+const replaceNamesWithIdsInUnitGroupKey = (unitGroupKey, schema) => {
+    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 (!Object.hasOwn(schema.typeObjectsByName, type)) {
+            return keyPart;
+        }
+        const typeObject = schema.typeObjectsByName[type];
+        if (!Object.hasOwn(typeObject.fieldObjectsByName, field)) {
+            return keyPart;
+        }
+        const fieldObject = typeObject.fieldObjectsByName[field];
+        return `${unitType}_${fieldObject.id}`;
+    })
+        .filter(Boolean)
+        .join("|");
+};
+exports.replaceNamesWithIdsInUnitGroupKey = replaceNamesWithIdsInUnitGroupKey;

package/lib/src/tsfixme.d.ts

@@ -0,0 +1 @@
+export type $TSFixMe = any;

package/lib/src/tsfixme.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/src/unit-definitions/avatar-collection.d.ts

@@ -0,0 +1,2 @@
+import { UnitDataDefinition, FieldUnit } from "../units/types";
+export declare const AvatarCollection: UnitDataDefinition<FieldUnit>;

package/lib/src/unit-definitions/avatar-collection.js

@@ -0,0 +1,53 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AvatarCollection = void 0;
+const compact_1 = __importDefault(require("lodash/compact"));
+const utils_1 = require("@fibery/expression-utils/src/utils");
+const select_1 = require("@fibery/query-utils/src/select");
+const get_export_value_1 = require("../unit-utils/get-export-value");
+const avatar_1 = require("../field-utils/avatar");
+const common_1 = require("../unit-utils/common");
+const type = "avatar-collection";
+exports.AvatarCollection = {
+    type,
+    name: "Avatar",
+    canEdit({ typeObject, unit: { expression } }) {
+        return (0, common_1.canEditFieldExpression)(typeObject, expression);
+    },
+    getLabel({ typeObject, unit }) {
+        const { expression } = unit;
+        const fieldObject = (0, utils_1.getFieldObjectByFieldExpression)({ typeObject, expression });
+        return `Avatar of ${fieldObject.title}`;
+    },
+    makeUnit: (0, common_1.makeUnitMethod)(type),
+    getQuerySelect({ typeObject, unit: { expression } }) {
+        const [userCollectionField] = expression;
+        const userCollectionFieldObject = typeObject.fieldObjectsByName[userCollectionField];
+        return {
+            [userCollectionField]: {
+                "q/from": [userCollectionField],
+                "q/select": (0, select_1.mergeDenormalizedSelects)((0, compact_1.default)([
+                    (0, select_1.toSelectMapClause)([
+                        userCollectionFieldObject.typeObject.idField,
+                        userCollectionFieldObject.typeObject.titleField,
+                    ]),
+                    (0, avatar_1.getAvatarSelectQuery)({
+                        typeObject: userCollectionFieldObject.typeObject,
+                    }),
+                ])),
+                "q/limit": "q/no-limit",
+            },
+        };
+    },
+    calculateErrors: common_1.calculateUnitExpressionErrors,
+    getExportValue: get_export_value_1.getReferenceCollectionExportValue,
+    canExport: () => true,
+    getExportLabel: ({ unit, typeObject }) => {
+        const { expression } = unit;
+        const fieldObject = (0, utils_1.getFieldObjectByFieldExpression)({ typeObject, expression });
+        return fieldObject.title;
+    },
+};

package/lib/src/unit-definitions/avatar-input.d.ts

@@ -0,0 +1,2 @@
+import { FieldUnit, UnitDataDefinition } from "../units/types";
+export declare const AvatarInput: UnitDataDefinition<FieldUnit>;

package/lib/src/unit-definitions/avatar-input.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AvatarInput = void 0;
+const avatar_1 = require("./avatar");
+const common_1 = require("../unit-utils/common");
+const type = "avatar-input";
+exports.AvatarInput = {
+    ...avatar_1.Avatar,
+    type,
+    name: "Avatar",
+    makeUnit: (0, common_1.makeUnitMethod)(type),
+};

package/lib/src/unit-definitions/avatar.d.ts

@@ -0,0 +1,2 @@
+import { UnitDataDefinition, FieldUnit } from "../units/types";
+export declare const Avatar: UnitDataDefinition<FieldUnit>;

package/lib/src/unit-definitions/avatar.js

@@ -0,0 +1,80 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Avatar = void 0;
+const compact_1 = __importDefault(require("lodash/compact"));
+const select_1 = require("@fibery/query-utils/src/select");
+const utils_1 = require("@fibery/expression-utils/src/utils");
+const array_1 = require("@fibery/helpers/utils/array");
+const avatar_1 = require("../field-utils/avatar");
+const common_1 = require("../unit-utils/common");
+const get_export_value_1 = require("../unit-utils/get-export-value");
+const type = "avatar";
+const getSelfAvatarSelectQuery = (typeObject) => (0, avatar_1.getAvatarSelectQuery)({ typeObject }) || {};
+exports.Avatar = {
+    type,
+    name: "Avatar",
+    canEdit({ typeObject, unit: { expression } }) {
+        if (!expression) {
+            return false;
+        }
+        return (0, common_1.canEditFieldExpression)(typeObject, expression);
+    },
+    getLabel({ typeObject, unit }) {
+        const { expression } = unit;
+        if (expression) {
+            const fieldObject = (0, utils_1.getFieldObjectByFieldExpression)({
+                typeObject,
+                expression,
+            });
+            if ((0, avatar_1.isAvatarExtensionEnabledType)(fieldObject.typeObject)) {
+                return `Avatar of ${fieldObject.title}`;
+            }
+        }
+        return "Avatar";
+    },
+    makeUnit(args) {
+        if (!args) {
+            // @ts-expect-error this is a unique polymorphic unit
+            return { type, kind: "db" };
+        }
+        (0, utils_1.assertIsValidExpression)(args.expression);
+        return { type, kind: "field", expression: args.expression };
+    },
+    getQuerySelect({ typeObject, unit: { expression } }) {
+        if (!expression) {
+            return getSelfAvatarSelectQuery(typeObject);
+        }
+        const field = (0, array_1.single)(expression);
+        const fieldObject = typeObject.fieldObjectsByName[field];
+        if ((0, avatar_1.isAvatarExtensionField)(fieldObject)) {
+            return getSelfAvatarSelectQuery(typeObject);
+        }
+        return (0, select_1.denormalizeSelect)({
+            [field]: (0, select_1.normalizeSelect)((0, select_1.mergeDenormalizedSelects)((0, compact_1.default)([
+                (0, select_1.toSelectMapClause)([fieldObject.typeObject.idField, fieldObject.typeObject.titleField]),
+                (0, avatar_1.getAvatarSelectQuery)({ typeObject: fieldObject.typeObject }),
+            ]))),
+        });
+    },
+    calculateErrors: common_1.calculateUnitExpressionErrors,
+    getExportValue: ({ typeObject, unit, object }) => {
+        if (unit.kind === "field") {
+            return (0, get_export_value_1.getReferenceExportValue)({ typeObject, unit, object });
+        }
+        return null;
+    },
+    canExport: ({ unit }) => {
+        return unit.kind === "field";
+    },
+    getExportLabel: ({ unit, typeObject }) => {
+        const { expression } = unit;
+        if (expression) {
+            const fieldObject = (0, utils_1.getFieldObjectByFieldExpression)({ typeObject, expression });
+            return fieldObject.title;
+        }
+        return "Avatar";
+    },
+};

package/lib/src/unit-definitions/back-references-list.d.ts

@@ -0,0 +1,2 @@
+import { FieldUnit, UnitDataDefinition } from "../units/types";
+export declare const BackReferencesList: UnitDataDefinition<FieldUnit>;

package/lib/src/unit-definitions/back-references-list.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BackReferencesList = void 0;
+const query_1 = require("@fibery/query-utils/src/query");
+const utils_1 = require("@fibery/expression-utils/src/utils");
+const back_references_1 = require("../field-utils/back-references");
+const common_1 = require("../unit-utils/common");
+const can_edit_field_1 = require("../unit-utils/can-edit-field");
+const get_field_label_1 = require("../unit-utils/get-field-label");
+const get_export_value_1 = require("../unit-utils/get-export-value");
+const type = "back-references-list";
+const getQuerySelect = (fieldObject) => {
+    const { name, typeObject } = fieldObject;
+    const orderBy = (0, query_1.calculateDefaultOrderBy)({ typeObject });
+    return {
+        [name]: {
+            "q/from": [name],
+            "q/select": (0, back_references_1.getEntityLinksListSelect)(typeObject),
+            "q/order-by": orderBy,
+            "q/limit": "q/no-limit",
+        },
+    };
+};
+exports.BackReferencesList = {
+    type,
+    name: "Back references list",
+    canEdit: can_edit_field_1.canEditField,
+    makeUnit: (0, common_1.makeUnitMethod)(type),
+    getLabel: get_field_label_1.getFieldLabel,
+    getQuerySelect: ({ typeObject, unit }) => {
+        const { expression } = unit;
+        const fieldObject = (0, utils_1.getFieldObjectByFieldExpression)({ typeObject, expression });
+        return getQuerySelect(fieldObject);
+    },
+    calculateErrors: common_1.calculateUnitExpressionErrors,
+    getExportValue: get_export_value_1.getExportValue,
+    canExport: () => true,
+};

package/lib/src/unit-definitions/bool-checkbox.d.ts

@@ -0,0 +1,2 @@
+import { FieldUnit, UnitDataDefinition } from "../units/types";
+export declare const BoolCheckbox: UnitDataDefinition<FieldUnit>;

package/lib/src/unit-definitions/bool-checkbox.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BoolCheckbox = void 0;
+const query_1 = require("@fibery/query-utils/src/query");
+const common_1 = require("../unit-utils/common");
+const can_edit_field_1 = require("../unit-utils/can-edit-field");
+const get_field_label_1 = require("../unit-utils/get-field-label");
+const get_export_value_1 = require("../unit-utils/get-export-value");
+const type = "bool-checkbox";
+exports.BoolCheckbox = {
+    type,
+    name: "Bool checkbox",
+    canEdit: can_edit_field_1.canEditField,
+    getLabel: get_field_label_1.getFieldLabel,
+    makeUnit: (0, common_1.makeUnitMethod)(type),
+    getQuerySelect({ typeObject, unit: { expression } }) {
+        return (0, query_1.getQuerySelectForExpression)({
+            typeObject,
+            expression,
+        });
+    },
+    calculateErrors: common_1.calculateUnitExpressionErrors,
+    getExportValue: get_export_value_1.getExportValue,
+    canExport: () => true,
+};

package/lib/src/unit-definitions/bool.d.ts

@@ -0,0 +1,2 @@
+import { FieldUnit, UnitDataDefinition } from "../units/types";
+export declare const Bool: UnitDataDefinition<FieldUnit>;

package/lib/src/unit-definitions/bool.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Bool = void 0;
+const query_1 = require("@fibery/query-utils/src/query");
+const can_edit_field_1 = require("../unit-utils/can-edit-field");
+const get_field_label_1 = require("../unit-utils/get-field-label");
+const common_1 = require("../unit-utils/common");
+const get_export_value_1 = require("../unit-utils/get-export-value");
+const type = "bool";
+exports.Bool = {
+    type,
+    name: "Bool",
+    canEdit: can_edit_field_1.canEditField,
+    getLabel: get_field_label_1.getFieldLabel,
+    makeUnit: (0, common_1.makeUnitMethod)(type),
+    getQuerySelect({ typeObject, unit: { expression } }) {
+        return (0, query_1.getQuerySelectForExpression)({ typeObject, expression });
+    },
+    calculateErrors: common_1.calculateUnitExpressionErrors,
+    getExportValue: get_export_value_1.getExportValue,
+    canExport: () => true,
+};

package/lib/src/unit-definitions/collection-count.d.ts

@@ -0,0 +1,2 @@
+import { FieldUnit, UnitDataDefinition } from "../units/types";
+export declare const CollectionCount: UnitDataDefinition<FieldUnit>;

package/lib/src/unit-definitions/collection-count.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CollectionCount = void 0;
+const array_1 = require("@fibery/helpers/utils/array");
+const utils_1 = require("@fibery/expression-utils/src/utils");
+const reference_collection_1 = require("../field-utils/reference-collection");
+const common_1 = require("../unit-utils/common");
+const type = "collection-count";
+exports.CollectionCount = {
+    type,
+    name: "Count",
+    canEdit: () => false,
+    makeUnit: (0, common_1.makeUnitMethod)(type),
+    getLabel({ typeObject, unit }) {
+        const { expression } = unit;
+        const fieldObject = (0, utils_1.getFieldObjectByFieldExpression)({ typeObject, expression });
+        if (fieldObject.name === "comments/comments") {
+            return fieldObject.title;
+        }
+        return `${fieldObject.title} Count`;
+    },
+    getQuerySelect({ unit: { expression } }) {
+        const field = (0, array_1.single)(expression);
+        return (0, reference_collection_1.getCollectionCountSelect)(field);
+    },
+    calculateErrors: common_1.calculateUnitExpressionErrors,
+    getExportValue: ({ object, unit }) => {
+        const field = (0, array_1.single)(unit.expression);
+        return object[(0, reference_collection_1.getCountKey)(field)];
+    },
+    canExport: () => true,
+};

package/lib/src/unit-definitions/color-input.d.ts

@@ -0,0 +1,2 @@
+import { FieldUnit, UnitDataDefinition } from "../units/types";
+export declare const ColorInput: UnitDataDefinition<FieldUnit>;

package/lib/src/unit-definitions/color-input.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ColorInput = void 0;
+const query_1 = require("@fibery/query-utils/src/query");
+const common_1 = require("../unit-utils/common");
+const can_edit_field_1 = require("../unit-utils/can-edit-field");
+const get_field_label_1 = require("../unit-utils/get-field-label");
+const type = "color-input";
+exports.ColorInput = {
+    type,
+    name: "Color",
+    canEdit: can_edit_field_1.canEditField,
+    makeUnit: (0, common_1.makeUnitMethod)(type),
+    getLabel: get_field_label_1.getFieldLabel,
+    getQuerySelect({ typeObject, unit: { expression } }) {
+        return (0, query_1.getQuerySelectForExpression)({ typeObject, expression });
+    },
+    calculateErrors: common_1.calculateUnitExpressionErrors,
+    getExportValue: () => null,
+    canExport: () => false,
+};

package/lib/src/unit-definitions/comments-list.d.ts

@@ -0,0 +1,2 @@
+import { FieldUnit, UnitDataDefinition } from "../units/types";
+export declare const CommentsList: UnitDataDefinition<FieldUnit>;

package/lib/src/unit-definitions/comments-list.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CommentsList = void 0;
+const utils_1 = require("@fibery/expression-utils/src/utils");
+const comments_1 = require("../field-utils/comments");
+const common_1 = require("../unit-utils/common");
+const get_export_value_1 = require("../unit-utils/get-export-value");
+const can_edit_field_1 = require("../unit-utils/can-edit-field");
+const get_field_label_1 = require("../unit-utils/get-field-label");
+const type = "comments-list";
+exports.CommentsList = {
+    type,
+    name: "Comments list",
+    canEdit: can_edit_field_1.canEditField,
+    makeUnit: (0, common_1.makeUnitMethod)(type),
+    getLabel: get_field_label_1.getFieldLabel,
+    getQuerySelect: ({ typeObject, unit }) => {
+        const { expression } = unit;
+        const fieldObject = (0, utils_1.getFieldObjectByFieldExpression)({ typeObject, expression });
+        return (0, comments_1.getQuerySelect)(fieldObject);
+    },
+    calculateErrors: common_1.calculateUnitExpressionErrors,
+    getExportValue: get_export_value_1.getExportValue,
+    canExport: () => true,
+};

package/lib/src/unit-definitions/date-range-combobox.d.ts

@@ -0,0 +1,2 @@
+import { FieldUnit, UnitDataDefinition } from "../units/types";
+export declare const DateRangeCombobox: UnitDataDefinition<FieldUnit>;

package/lib/src/unit-definitions/date-range-combobox.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DateRangeCombobox = void 0;
+const query_1 = require("@fibery/query-utils/src/query");
+const common_1 = require("../unit-utils/common");
+const get_export_value_1 = require("../unit-utils/get-export-value");
+const get_field_label_1 = require("../unit-utils/get-field-label");
+const can_edit_field_1 = require("../unit-utils/can-edit-field");
+const type = "date-range-combobox";
+exports.DateRangeCombobox = {
+    type,
+    name: "Date range",
+    canEdit: can_edit_field_1.canEditField,
+    makeUnit: (0, common_1.makeUnitMethod)(type),
+    getLabel: get_field_label_1.getFieldLabel,
+    getQuerySelect: ({ typeObject, unit: { expression } }) => {
+        return (0, query_1.getQuerySelectForExpression)({ typeObject, expression });
+    },
+    calculateErrors: common_1.calculateUnitExpressionErrors,
+    getExportValue: get_export_value_1.getDateRangeExportValue,
+    canExport: () => true,
+};

package/lib/src/unit-definitions/date-range.d.ts

@@ -0,0 +1,2 @@
+import { FieldUnit, UnitDataDefinition } from "../units/types";
+export declare const DateRange: UnitDataDefinition<FieldUnit>;