@fibery/views 17.0.4 → 18.0.1

package/lib/index.js

@@ -0,0 +1,17 @@
+"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./src"), exports);

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

@@ -0,0 +1,20 @@
+import { FieldObject, TypeObject } from "@fibery/schema";
+export declare const AVATAR_MIXIN_NAME = "avatar/avatar-mixin";
+export declare const AVATAR_EXTENSION_FIELD = "avatar/avatars";
+export declare const isAvatarExtensionEnabledType: (typeObject: TypeObject) => boolean;
+export declare const isAvatarExtensionField: (fieldObject: FieldObject) => boolean;
+export declare const getAvatarSelect: (fieldObject: FieldObject) => import("@fibery/expression-utils").Select;
+export declare const getAvatarSelectQuery: ({ typeObject }: {
+    typeObject: TypeObject;
+}) => {
+    [x: string]: "fibery/id" | "__NOTHING_INTERESTING__TitleField__" | {
+        "q/from": string[];
+        "q/limit": string;
+        "q/select": import("@fibery/expression-utils").Select;
+    };
+    "fibery/id": "fibery/id";
+    __NOTHING_INTERESTING__TitleField__: "__NOTHING_INTERESTING__TitleField__";
+} | {
+    "fibery/id"?: undefined;
+    __NOTHING_INTERESTING__TitleField__?: undefined;
+};

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

@@ -0,0 +1,42 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getAvatarSelectQuery = exports.getAvatarSelect = exports.isAvatarExtensionField = exports.isAvatarExtensionEnabledType = exports.AVATAR_EXTENSION_FIELD = exports.AVATAR_MIXIN_NAME = void 0;
+const compact_1 = __importDefault(require("lodash/compact"));
+const select_1 = require("@fibery/query-utils/src/select");
+exports.AVATAR_MIXIN_NAME = "avatar/avatar-mixin";
+exports.AVATAR_EXTENSION_FIELD = "avatar/avatars";
+const isAvatarExtensionEnabledType = (typeObject) => {
+    return (typeObject &&
+        typeObject.installedMixins.has(exports.AVATAR_MIXIN_NAME) &&
+        (0, exports.isAvatarExtensionField)(typeObject.fieldObjectsByName[exports.AVATAR_EXTENSION_FIELD]));
+};
+exports.isAvatarExtensionEnabledType = isAvatarExtensionEnabledType;
+const isAvatarExtensionField = (fieldObject) => {
+    return fieldObject.name === exports.AVATAR_EXTENSION_FIELD && fieldObject.type === "fibery/file";
+};
+exports.isAvatarExtensionField = isAvatarExtensionField;
+const getAvatarSelect = (fieldObject) => (0, select_1.toSelectMapClause)((0, compact_1.default)([fieldObject.typeObject.idField, fieldObject.typeObject.titleField, "fibery/content-type", "fibery/secret"]));
+exports.getAvatarSelect = getAvatarSelect;
+const getAvatarSelectQuery = ({ typeObject }) => {
+    if ((0, exports.isAvatarExtensionEnabledType)(typeObject)) {
+        const fieldObject = typeObject.fieldObjectsByName[exports.AVATAR_EXTENSION_FIELD];
+        const idField = fieldObject.typeObject.idField;
+        const typeTitleField = typeObject.titleField;
+        return {
+            [idField]: idField,
+            [typeTitleField]: typeTitleField,
+            [fieldObject.name]: {
+                "q/from": [fieldObject.name],
+                "q/limit": "q/no-limit",
+                "q/select": (0, exports.getAvatarSelect)(fieldObject),
+            },
+        };
+    }
+    else {
+        return {};
+    }
+};
+exports.getAvatarSelectQuery = getAvatarSelectQuery;

package/lib/src/field-utils/back-references.d.ts

@@ -0,0 +1,15 @@
+import { FieldObject, TypeObject } from "@fibery/schema";
+export declare const isReferenceExtensionField: (fieldObject: FieldObject) => boolean;
+export declare const getEntityLinksListSelect: (typeObject: TypeObject) => {
+    "fibery/id": "fibery/id";
+    "fibery/creation-date": string;
+    "Collaboration~Documents/ParagraphSecret": string;
+    "Collaboration~Documents/FromTypeId": string;
+    "Collaboration~Documents/FromEntityId": string;
+    "Collaboration~Documents/FromEntityField": {
+        "fibery/id": string[];
+    };
+    "fibery/created-by": {
+        "fibery/id": string[];
+    };
+};

package/lib/src/field-utils/back-references.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getEntityLinksListSelect = exports.isReferenceExtensionField = void 0;
+const isReferenceExtensionField = (fieldObject) => fieldObject.type === "Collaboration~Documents/Reference";
+exports.isReferenceExtensionField = isReferenceExtensionField;
+const getEntityLinksListSelect = (typeObject) => {
+    return {
+        [typeObject.idField]: typeObject.idField,
+        "fibery/creation-date": "fibery/creation-date",
+        "Collaboration~Documents/ParagraphSecret": "Collaboration~Documents/ParagraphSecret",
+        "Collaboration~Documents/FromTypeId": "Collaboration~Documents/FromTypeId",
+        "Collaboration~Documents/FromEntityId": "Collaboration~Documents/FromEntityId",
+        "Collaboration~Documents/FromEntityField": {
+            "fibery/id": ["Collaboration~Documents/FromEntityField", "fibery/id"],
+        },
+        "fibery/created-by": {
+            "fibery/id": ["fibery/created-by", "fibery/id"],
+        },
+    };
+};
+exports.getEntityLinksListSelect = getEntityLinksListSelect;

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

@@ -0,0 +1,60 @@
+import { FieldObject, TypeObject } from "@fibery/schema";
+import { accessCheckKey } from "../unit-utils/access";
+export declare const isCommentExtensionField: (fieldObject: FieldObject) => boolean;
+export declare const getCommentsListSelect: (typeObject: TypeObject) => {
+    "fibery/id": "fibery/id";
+    "fibery/public-id": "fibery/public-id";
+    "fibery/creation-date": string;
+    "comment/document-secret": string;
+    "comments/parent": {
+        "fibery/id": string[];
+    };
+    "fibery/created-by": {
+        [accessCheckKey]: (string | string[])[];
+        "fibery/id": string[];
+        "user/email": string[];
+        "user/name": string[];
+        "avatar/avatars": {
+            "q/from": string[];
+            "q/limit": string;
+            "q/select": {
+                "fibery/id": string[];
+                "fibery/name": string[];
+                "fibery/content-type": string[];
+                "fibery/secret": string[];
+            };
+        };
+    };
+};
+export declare const getQuerySelect: (fieldObject: FieldObject) => {
+    [name]: {
+        "q/from": string[];
+        "q/select": {
+            "fibery/id": "fibery/id";
+            "fibery/public-id": "fibery/public-id";
+            "fibery/creation-date": string;
+            "comment/document-secret": string;
+            "comments/parent": {
+                "fibery/id": string[];
+            };
+            "fibery/created-by": {
+                [accessCheckKey]: (string | string[])[];
+                "fibery/id": string[];
+                "user/email": string[];
+                "user/name": string[];
+                "avatar/avatars": {
+                    "q/from": string[];
+                    "q/limit": string;
+                    "q/select": {
+                        "fibery/id": string[];
+                        "fibery/name": string[];
+                        "fibery/content-type": string[];
+                        "fibery/secret": string[];
+                    };
+                };
+            };
+        };
+        "q/order-by": import("@fibery/expression-utils").OrderBy | undefined;
+        "q/limit": string;
+    };
+};

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

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getQuerySelect = exports.getCommentsListSelect = exports.isCommentExtensionField = void 0;
+const query_1 = require("@fibery/query-utils/src/query");
+const access_1 = require("../unit-utils/access");
+const isCommentExtensionField = (fieldObject) => fieldObject.name === "comments/comments";
+exports.isCommentExtensionField = isCommentExtensionField;
+const getCommentsListSelect = (typeObject) => {
+    return {
+        [typeObject.idField]: typeObject.idField,
+        [typeObject.publicIdField]: typeObject.publicIdField,
+        "fibery/creation-date": "fibery/creation-date",
+        "comment/document-secret": "comment/document-secret",
+        "comments/parent": { "fibery/id": ["comments/parent", "fibery/id"] },
+        "fibery/created-by": {
+            [access_1.accessCheckKey]: ["q/access?", ["fibery/created-by", "user/name"]],
+            "fibery/id": ["fibery/created-by", "fibery/id"],
+            "user/email": ["fibery/created-by", "user/email"],
+            "user/name": ["fibery/created-by", "user/name"],
+            "avatar/avatars": {
+                "q/from": ["fibery/created-by", "avatar/avatars"],
+                "q/limit": "q/no-limit",
+                "q/select": {
+                    "fibery/id": ["fibery/id"],
+                    "fibery/name": ["fibery/name"],
+                    "fibery/content-type": ["fibery/content-type"],
+                    "fibery/secret": ["fibery/secret"],
+                },
+            },
+        },
+    };
+};
+exports.getCommentsListSelect = getCommentsListSelect;
+const getQuerySelect = (fieldObject) => {
+    const { name, typeObject } = fieldObject;
+    const orderBy = (0, query_1.calculateDefaultOrderBy)({ typeObject });
+    return {
+        [name]: {
+            "q/from": [name],
+            "q/select": (0, exports.getCommentsListSelect)(typeObject),
+            "q/order-by": orderBy,
+            "q/limit": "q/no-limit",
+        },
+    };
+};
+exports.getQuerySelect = getQuerySelect;

package/lib/src/field-utils/date-time.d.ts

@@ -0,0 +1,14 @@
+import moment, { Moment, MomentInput, unitOfTime } from "moment/moment";
+export declare const parseDate: (isoDate: MomentInput) => moment.Moment;
+export declare const serializeDate: (momentDate: Moment) => string;
+export declare const parseDateTime: (isoDateTime: MomentInput) => moment.Moment;
+export declare const serializeDateTime: (momentDate: Moment) => string;
+export declare const parseStart: ({ value, type }: {
+    value: MomentInput;
+    type: string;
+}) => moment.Moment;
+export declare const parseEnd: ({ value, type, minimumDelta, }: {
+    value: MomentInput;
+    type: string;
+    minimumDelta?: [number, unitOfTime.DurationConstructor] | null;
+}) => moment.Moment;

package/lib/src/field-utils/date-time.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.parseEnd = exports.parseStart = exports.serializeDateTime = exports.parseDateTime = exports.serializeDate = exports.parseDate = void 0;
+const moment_1 = __importDefault(require("moment/moment"));
+const errors_1 = require("@fibery/expression-utils/src/errors");
+const utils_1 = require("@fibery/expression-utils/src/utils");
+const defaultDateDelta = [1, "day"];
+const defaultDateTimeDelta = [1, "second"];
+const parseDate = (isoDate) => {
+    return (0, moment_1.default)(isoDate).set({ hour: 12 });
+};
+exports.parseDate = parseDate;
+const serializeDate = (momentDate) => {
+    return momentDate.format("YYYY-MM-DD");
+};
+exports.serializeDate = serializeDate;
+const parseDateTime = (isoDateTime) => {
+    return moment_1.default.utc(isoDateTime).local();
+};
+exports.parseDateTime = parseDateTime;
+const serializeDateTime = (momentDate) => {
+    return momentDate.toISOString();
+};
+exports.serializeDateTime = serializeDateTime;
+const parseStart = ({ value, type }) => {
+    if ((0, utils_1.isDateType)(type)) {
+        return (0, exports.parseDate)(value).startOf("day");
+    }
+    if ((0, utils_1.isDateTimeType)(type)) {
+        return (0, exports.parseDateTime)(value).startOf("second");
+    }
+    throw new errors_1.NotImplementedError(type);
+};
+exports.parseStart = parseStart;
+const parseEnd = ({ value, type, minimumDelta = null, }) => {
+    if ((0, utils_1.isDateType)(type)) {
+        if ((0, utils_1.isRangeType)(type)) {
+            return (0, exports.parseDate)(value)
+                .subtract(...(minimumDelta || defaultDateDelta))
+                .endOf("day");
+        }
+        else {
+            return (0, exports.parseDate)(value).endOf("day");
+        }
+    }
+    if ((0, utils_1.isDateTimeType)(type)) {
+        return (0, exports.parseDateTime)(value)
+            .subtract(...(minimumDelta || defaultDateTimeDelta))
+            .startOf("second");
+    }
+    throw new errors_1.NotImplementedError(type);
+};
+exports.parseEnd = parseEnd;

package/lib/src/field-utils/enum-value.d.ts

@@ -0,0 +1,13 @@
+import { FieldObject, TypeObject } from "@fibery/schema";
+import { NumberFormat } from "./number";
+export declare const enumNumberFieldName = "Value";
+export declare const getEnumNumberFieldName: (namespace: string) => string;
+export declare const defaultEnumNumberFieldMeta: {
+    numberFormat: NumberFormat;
+    numberPrecision: number;
+    numberUnit: null;
+    numberCurrencyCode: null;
+    numberUseThousandSeparator: boolean;
+};
+export declare const getIsNumberFieldObjectTaken: (typeObject: TypeObject) => boolean;
+export declare const getNumberFieldObject: (typeObject: TypeObject) => FieldObject | undefined;

package/lib/src/field-utils/enum-value.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getNumberFieldObject = exports.getIsNumberFieldObjectTaken = exports.defaultEnumNumberFieldMeta = exports.getEnumNumberFieldName = exports.enumNumberFieldName = void 0;
+const number_1 = require("./number");
+exports.enumNumberFieldName = "Value";
+const getEnumNumberFieldName = (namespace) => `${namespace}/${exports.enumNumberFieldName}`;
+exports.getEnumNumberFieldName = getEnumNumberFieldName;
+exports.defaultEnumNumberFieldMeta = {
+    numberFormat: number_1.NumberFormat.NUMBER,
+    numberPrecision: 0,
+    numberUnit: null,
+    numberCurrencyCode: null,
+    numberUseThousandSeparator: true,
+};
+const isNumeric = (fieldObject) => {
+    return fieldObject.type === "fibery/int" || fieldObject.type === "fibery/decimal";
+};
+const getIsNumberFieldObjectTaken = (typeObject) => {
+    return Boolean(typeObject.fieldObjects.find((fieldObject) => {
+        return fieldObject.nameParts.name === exports.enumNumberFieldName && !isNumeric(fieldObject);
+    }));
+};
+exports.getIsNumberFieldObjectTaken = getIsNumberFieldObjectTaken;
+const getNumberFieldObject = (typeObject) => {
+    return typeObject.fieldObjects.find((fieldObject) => {
+        return fieldObject.nameParts.name === exports.enumNumberFieldName && isNumeric(fieldObject);
+    });
+};
+exports.getNumberFieldObject = getNumberFieldObject;

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

@@ -0,0 +1,4 @@
+import { TypeObject } from "@fibery/schema";
+export declare const getFilesSelect: ({ typeObject }: {
+    typeObject: TypeObject;
+}) => import("@fibery/expression-utils").Select;

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

@@ -0,0 +1,18 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getFilesSelect = void 0;
+const compact_1 = __importDefault(require("lodash/compact"));
+const select_1 = require("@fibery/query-utils/src/select");
+const getFilesSelect = ({ typeObject }) => (0, select_1.toSelectMapClause)((0, compact_1.default)([
+    typeObject.idField,
+    typeObject.titleField,
+    "fibery/creation-date",
+    "fibery/content-type",
+    "fibery/content-length",
+    "fibery/secret",
+    "fibery/rank",
+]));
+exports.getFilesSelect = getFilesSelect;

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

@@ -0,0 +1,10 @@
+import { FieldObject, TypeObject } from "@fibery/schema";
+export declare const ICON_MIXIN_NAME = "icon/icon-mixin";
+export declare const ICON_EXTENSION_FIELD = "icon/icon";
+export declare const isIconExtensionEnabledType: (typeObject: TypeObject) => boolean;
+export declare const isIconExtensionField: (fieldObject: FieldObject) => boolean;
+export declare const getEntityIconSelect: ({ typeObject }: {
+    typeObject: TypeObject;
+}) => {
+    [x: string]: string;
+};

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

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getEntityIconSelect = exports.isIconExtensionField = exports.isIconExtensionEnabledType = exports.ICON_EXTENSION_FIELD = exports.ICON_MIXIN_NAME = void 0;
+exports.ICON_MIXIN_NAME = "icon/icon-mixin";
+exports.ICON_EXTENSION_FIELD = "icon/icon";
+const isIconExtensionEnabledType = (typeObject) => {
+    return (typeObject.installedMixins.has(exports.ICON_MIXIN_NAME) &&
+        (0, exports.isIconExtensionField)(typeObject.fieldObjectsByName[exports.ICON_EXTENSION_FIELD]));
+};
+exports.isIconExtensionEnabledType = isIconExtensionEnabledType;
+const isIconExtensionField = (fieldObject) => {
+    return fieldObject.name === exports.ICON_EXTENSION_FIELD && fieldObject.type === "fibery/emoji";
+};
+exports.isIconExtensionField = isIconExtensionField;
+const getEntityIconSelect = ({ typeObject }) => {
+    if ((0, exports.isIconExtensionEnabledType)(typeObject)) {
+        const fieldObject = typeObject.fieldObjectsByName[exports.ICON_EXTENSION_FIELD];
+        return {
+            [fieldObject.name]: fieldObject.name,
+        };
+    }
+    else {
+        return {};
+    }
+};
+exports.getEntityIconSelect = getEntityIconSelect;

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

@@ -0,0 +1,31 @@
+import { FieldObject } from "@fibery/schema";
+export declare enum NumberFormat {
+    NUMBER = "Number",
+    MONEY = "Money",
+    PERCENT = "Percent"
+}
+export type NumberDisplaySettings = {
+    thousandSeparator: string;
+    decimalSeparator: string;
+};
+export type NumberFieldMeta = {
+    numberFormat: NumberFormat;
+    numberPrecision: number;
+    numberUnit: string | null;
+    numberCurrencyCode: string | null;
+    numberUseThousandSeparator: boolean;
+};
+export declare const getDefaultCurrencyCode: (numberFormat: NumberFormat) => "USD" | null;
+export declare const getDefaultPrecision: (numberFormat: NumberFormat) => 0 | 2;
+export declare const getInitialNumberFieldMeta: () => NumberFieldMeta;
+export declare const externalizePrecision: (numberFormat: NumberFormat, numberPrecision: number) => number;
+export declare function getNumberFormatOrDefault(numberFormat: NumberFormat | undefined): NumberFormat;
+export declare const parseNumberMeta: ({ rawNumberPrecision, rawNumberUnit, rawNumberCurrencyCode, rawNumberUseThousandSeparator, rawNumberFormat, fieldType, }: {
+    rawNumberPrecision: unknown;
+    rawNumberUnit: unknown;
+    rawNumberCurrencyCode: unknown;
+    rawNumberUseThousandSeparator: unknown;
+    rawNumberFormat: unknown;
+    fieldType: string;
+}) => NumberFieldMeta;
+export declare const parseNumberFieldMeta: (fieldObject: FieldObject) => NumberFieldMeta;

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

@@ -0,0 +1,91 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseNumberFieldMeta = exports.parseNumberMeta = exports.externalizePrecision = exports.getInitialNumberFieldMeta = exports.getDefaultPrecision = exports.getDefaultCurrencyCode = exports.NumberFormat = void 0;
+exports.getNumberFormatOrDefault = getNumberFormatOrDefault;
+const curry_1 = __importDefault(require("lodash/curry"));
+const flow_1 = __importDefault(require("lodash/flow"));
+var NumberFormat;
+(function (NumberFormat) {
+    NumberFormat["NUMBER"] = "Number";
+    NumberFormat["MONEY"] = "Money";
+    NumberFormat["PERCENT"] = "Percent";
+})(NumberFormat || (exports.NumberFormat = NumberFormat = {}));
+const DEFAULT_NUMBER_FORMAT = NumberFormat.NUMBER;
+const getDefaultCurrencyCode = (numberFormat) => {
+    if (numberFormat === NumberFormat.MONEY) {
+        return "USD";
+    }
+    return null;
+};
+exports.getDefaultCurrencyCode = getDefaultCurrencyCode;
+const getDefaultPrecision = (numberFormat) => {
+    if (numberFormat === NumberFormat.MONEY) {
+        return 2;
+    }
+    return 0;
+};
+exports.getDefaultPrecision = getDefaultPrecision;
+const getInitialNumberFieldMeta = () => {
+    return {
+        numberFormat: DEFAULT_NUMBER_FORMAT,
+        numberPrecision: (0, exports.getDefaultPrecision)(DEFAULT_NUMBER_FORMAT),
+        numberUnit: null,
+        numberCurrencyCode: (0, exports.getDefaultCurrencyCode)(DEFAULT_NUMBER_FORMAT),
+        numberUseThousandSeparator: true,
+    };
+};
+exports.getInitialNumberFieldMeta = getInitialNumberFieldMeta;
+const parsePrecisionWithBackwardCompatibility = (fieldType) => (rawNumberPrecision) => {
+    // For some reason there exist fields of type fibery/int with precision > 0
+    const isInteger = fieldType === "fibery/int";
+    return isInteger ? 0 : Number(rawNumberPrecision) || 1;
+};
+const internalizePrecision = (0, curry_1.default)((numberFormat, numberPrecision) => {
+    if (numberFormat === NumberFormat.PERCENT) {
+        return numberPrecision - 2;
+    }
+    return numberPrecision;
+});
+const externalizePrecision = (numberFormat, numberPrecision) => {
+    if (numberFormat === NumberFormat.PERCENT) {
+        return numberPrecision + 2;
+    }
+    return numberPrecision;
+};
+exports.externalizePrecision = externalizePrecision;
+function getNumberFormatOrDefault(numberFormat) {
+    return numberFormat || DEFAULT_NUMBER_FORMAT;
+}
+const parseNumberMeta = ({ rawNumberPrecision, rawNumberUnit, rawNumberCurrencyCode, rawNumberUseThousandSeparator, rawNumberFormat, fieldType, }) => {
+    const numberFormat = getNumberFormatOrDefault(rawNumberFormat);
+    const numberPrecision = (0, flow_1.default)([
+        parsePrecisionWithBackwardCompatibility(fieldType),
+        internalizePrecision(numberFormat),
+    ])(rawNumberPrecision);
+    const numberUnit = rawNumberUnit || null;
+    const numberCurrencyCode = numberFormat === NumberFormat.MONEY ? rawNumberCurrencyCode : null;
+    const numberUseThousandSeparator = Boolean(rawNumberUseThousandSeparator);
+    return {
+        numberFormat,
+        numberPrecision,
+        numberUnit,
+        numberCurrencyCode,
+        numberUseThousandSeparator,
+    };
+};
+exports.parseNumberMeta = parseNumberMeta;
+const parseNumberFieldMeta = (fieldObject) => {
+    const { "ui/number-precision": rawNumberPrecision, "ui/number-unit": rawNumberUnit, "ui/number-currency-code": rawNumberCurrencyCode, "ui/number-thousand-separator?": rawNumberUseThousandSeparator, "ui/number-format": rawNumberFormat, } = fieldObject.rawMeta;
+    return (0, exports.parseNumberMeta)({
+        rawNumberPrecision,
+        rawNumberUnit,
+        rawNumberCurrencyCode,
+        rawNumberUseThousandSeparator,
+        rawNumberFormat,
+        fieldType: fieldObject.type,
+    });
+};
+exports.parseNumberFieldMeta = parseNumberFieldMeta;

package/lib/src/field-utils/reference-collection.d.ts

@@ -0,0 +1,18 @@
+import { FieldObject } from "@fibery/schema";
+import { QueryLimit } from "@fibery/expression-utils/src/types";
+export declare const REFERENCE_COLLECTION_LIMIT = 1000;
+export declare const makeCollectionCountExpression: (field: string) => (string | string[])[];
+export declare const getCountKey: (field: string) => string;
+export declare const getCollectionCountSelect: (field: string) => {
+    [x: string]: (string | string[])[];
+};
+export declare const calculateReferenceCollectionQuery: ({ fieldObject, limit, }: {
+    fieldObject: FieldObject;
+    limit: QueryLimit;
+}) => {
+    [x: string]: {
+        "q/from": string[];
+        "q/select": any;
+        "q/limit": QueryLimit;
+    };
+};

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

@@ -0,0 +1,45 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.calculateReferenceCollectionQuery = exports.getCollectionCountSelect = exports.getCountKey = exports.makeCollectionCountExpression = exports.REFERENCE_COLLECTION_LIMIT = void 0;
+const compact_1 = __importDefault(require("lodash/compact"));
+const select_1 = require("@fibery/query-utils/src/select");
+const dynamic_keys_1 = require("../unit-utils/dynamic-keys");
+const access_1 = require("../unit-utils/access");
+const enums_1 = require("../unit-utils/enums");
+const avatar_1 = require("./avatar");
+const icon_1 = require("./icon");
+const file_1 = require("./file");
+exports.REFERENCE_COLLECTION_LIMIT = 1000;
+const makeCollectionCountExpression = (field) => ["q/count", [field, "fibery/id"]];
+exports.makeCollectionCountExpression = makeCollectionCountExpression;
+const getCountKey = (field) => (0, dynamic_keys_1.makeDynamicKey)(dynamic_keys_1.collectionCountKeyPrefix, field);
+exports.getCountKey = getCountKey;
+const getCollectionCountSelect = (field) => ({
+    [(0, exports.getCountKey)(field)]: (0, exports.makeCollectionCountExpression)(field),
+});
+exports.getCollectionCountSelect = getCollectionCountSelect;
+const calculateReferenceCollectionQuery = ({ fieldObject, limit, }) => {
+    return {
+        [fieldObject.name]: {
+            "q/from": [fieldObject.name],
+            "q/select": (0, select_1.mergeDenormalizedSelects)((0, compact_1.default)([
+                (0, select_1.toSelectMapClause)((0, compact_1.default)([
+                    fieldObject.typeObject.idField,
+                    fieldObject.typeObject.titleField,
+                    // keep public id - required to build Links
+                    fieldObject.typeObject.publicIdField,
+                ])),
+                (0, access_1.generateAccessCheckQueryExpression)({ typeObject: fieldObject.typeObject }),
+                (0, avatar_1.getAvatarSelectQuery)({ typeObject: fieldObject.typeObject }),
+                (0, icon_1.getEntityIconSelect)({ typeObject: fieldObject.typeObject }),
+                fieldObject.type === "fibery/file" && (0, file_1.getFilesSelect)(fieldObject),
+                (0, enums_1.getEnumIconColorQuery)({ typeObject: fieldObject.typeObject }),
+            ])),
+            "q/limit": limit,
+        },
+    };
+};
+exports.calculateReferenceCollectionQuery = calculateReferenceCollectionQuery;

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

@@ -0,0 +1,7 @@
+import { FieldObject, TypeObject } from "@fibery/schema";
+import { Expression } from "@fibery/expression-utils";
+import type { Select } from "@fibery/expression-utils/src/types";
+export declare const getReferenceTypeSelectClause: ({ typeObject }: {
+    typeObject: TypeObject;
+}, contextPath: Expression) => Select;
+export declare const getReferenceFieldNormalizedSelectClause: (fieldObject: FieldObject, contextPath: Expression) => any;