@fibery/views 17.0.4 → 18.0.2

package/lib/src/units/make-factory.js

@@ -0,0 +1,245 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeUnitDefinitionsFactory = void 0;
+const compact_1 = __importDefault(require("lodash/compact"));
+const constant_1 = __importDefault(require("lodash/constant"));
+const flatMap_1 = __importDefault(require("lodash/flatMap"));
+const groupBy_1 = __importDefault(require("lodash/groupBy"));
+const isPlainObject_1 = __importDefault(require("lodash/isPlainObject"));
+const mapValues_1 = __importDefault(require("lodash/mapValues"));
+const sortBy_1 = __importDefault(require("lodash/sortBy"));
+const trace_1 = require("@fibery/helpers/utils/trace");
+const number_1 = require("../field-utils/number");
+const text_1 = require("../field-utils/text");
+const avatar_1 = require("../field-utils/avatar");
+const comments_1 = require("../field-utils/comments");
+const back_references_1 = require("../field-utils/back-references");
+const relation_view_1 = require("../field-utils/relation-view");
+const select_1 = require("@fibery/query-utils/src/select");
+const common_1 = require("../unit-utils/common");
+const not_found_1 = require("../unit-definitions/not-found");
+const array_1 = require("@fibery/helpers/utils/array");
+const user_role_1 = require("../field-utils/user-role");
+const NoUnitsCreator = () => [];
+const makeUnitDefinitionsFactory = (allUnitDefinitions) => {
+    const { BackReferencesList, Bool, BoolCheckbox, ColorInput, CommentsList, Text, TextInput, Email, EmailInput, Emoji, IconInput, JsonInput, Number, NumberInput, ProgressBar, ReferenceCombobox, ReferenceCollection, ReferenceCollectionList, ReferenceCollectionView, ReferenceCollectionCombobox, FileReference, FileCompactReference, FilesGallery, FileList, FileListItem, FileLList, FileLListItem, FileCollectionCount, FileCompactCollection, Date, DateTimeCombobox, DateRange, DateRangeCombobox, Avatar, AvatarCollection, AvatarInput, CollectionCount, Reference, ReferenceIcon, TypeIcon, TypeBadge, TypeBadgeAbbr, Title, TitleInput, Id, UserButton, Phone, PhoneInput, Location, LocationInput, SingleLocationPreview, GeometryPreview, RichText, RichTextSnippet, RichTextDocument, CommentsCollection, Url, UrlInput, UserRole, UserRoleInput, IconButton, } = allUnitDefinitions;
+    const unitsFactoryByBasicFieldType = {
+        "fibery/bool": () => [Bool, BoolCheckbox],
+        "fibery/date": () => [Date, DateTimeCombobox],
+        "fibery/date-range": () => [DateRange, DateRangeCombobox],
+        "fibery/date-time": () => [Date, DateTimeCombobox],
+        "fibery/date-time-range": () => [DateRange, DateRangeCombobox],
+        "fibery/text": (fieldObject) => {
+            const lookup = {
+                [text_1.TextUIMeta.Phone]: [Phone, PhoneInput, IconButton],
+                [text_1.TextUIMeta.Email]: [Email, EmailInput, IconButton],
+                [text_1.TextUIMeta.URL]: [Url, UrlInput, IconButton],
+            };
+            const key = fieldObject.rawMeta[text_1.TextUIMetaKey];
+            return lookup[key] || [Text, TextInput];
+        },
+        "fibery/url": () => [Url, UrlInput, IconButton],
+        "fibery/email": () => [Email, EmailInput, IconButton],
+        "fibery/emoji": () => [Emoji, IconInput],
+        "fibery/int": () => [Number, NumberInput],
+        "fibery/location": () => [SingleLocationPreview, Location, LocationInput],
+        "fibery/rich-text": NoUnitsCreator,
+        "fibery/rank": NoUnitsCreator,
+        "fibery/json-value": () => [GeometryPreview, JsonInput],
+        "fibery/uuid": NoUnitsCreator,
+        "fibery/decimal": (fieldObject) => [
+            Number,
+            NumberInput,
+            (0, number_1.parseNumberFieldMeta)(fieldObject).numberFormat === number_1.NumberFormat.PERCENT && ProgressBar,
+        ],
+        "fibery/color": () => [ColorInput],
+    };
+    const fallbackFieldCreator = (fieldObject) => {
+        (0, trace_1.traceError)(`basicFieldCreators["${fieldObject.type}"] is not defined`);
+        return [];
+    };
+    const unitsFactoryByFieldKind = {
+        ":field/basic": (fieldObject) => {
+            const creator = unitsFactoryByBasicFieldType[fieldObject.type] || fallbackFieldCreator;
+            return creator(fieldObject);
+        },
+        ":field/reference": (fieldObject) => {
+            if (FileReference && FileCompactReference && fieldObject.typeObject.name === "fibery/file") {
+                return [FileLListItem, FileCompactReference, FileListItem, FileReference].filter(Boolean);
+            }
+            return [
+                (0, avatar_1.isAvatarExtensionEnabledType)(fieldObject.typeObject) && Avatar,
+                fieldObject.name === "workflow/state" && ReferenceIcon,
+                Reference,
+                ReferenceCombobox,
+            ];
+        },
+        ":field/reference-collection": (fieldObject, options) => {
+            const common = [CollectionCount, (0, avatar_1.isAvatarExtensionEnabledType)(fieldObject.typeObject) && AvatarCollection];
+            if ((0, relation_view_1.isRelationViewField)(fieldObject) && !options.isSharingMode) {
+                return [...common, ReferenceCollection, ReferenceCollectionCombobox, ReferenceCollectionView];
+            }
+            if ((0, back_references_1.isReferenceExtensionField)(fieldObject)) {
+                return [...common, BackReferencesList];
+            }
+            if ((0, comments_1.isCommentExtensionField)(fieldObject)) {
+                return [...common, CommentsList];
+            }
+            if (fieldObject.typeObject.name === "fibery/view") {
+                return [...common, ReferenceCollection, ReferenceCollectionCombobox, ReferenceCollectionList];
+            }
+            if (fieldObject.typeObject.name === "fibery/file") {
+                return [
+                    FileLList,
+                    FileCompactCollection ? FileCompactCollection : ReferenceCollection,
+                    FileCollectionCount ? FileCollectionCount : CollectionCount,
+                    FilesGallery,
+                    FileList,
+                ].filter(Boolean);
+            }
+            if (fieldObject.typeObject.isEnum) {
+                return [...common, ReferenceCollection, ReferenceCollectionCombobox];
+            }
+            if (fieldObject.cardinality === ":cardinality/many-to-many" && fieldObject.type === "fibery/user") {
+                return [...common, ReferenceCollection, ReferenceCollectionCombobox];
+            }
+            return [...common, ReferenceCollection, ReferenceCollectionCombobox, ReferenceCollectionList];
+        },
+    };
+    const getUnitsForField = (fieldObject, options = {}) => {
+        const makeUnit = (Unit) => Unit.makeUnit({ expression: [fieldObject.name] });
+        const { showHiddenFields } = options;
+        if (fieldObject.isPublicId) {
+            return [Id].filter(Boolean).map(makeUnit);
+        }
+        if (fieldObject.isTitle) {
+            return [Title, TitleInput].filter(Boolean).map(makeUnit);
+        }
+        if ((0, avatar_1.isAvatarExtensionField)(fieldObject)) {
+            return [Avatar, AvatarInput].filter(Boolean).map(makeUnit);
+        }
+        if (fieldObject.type === "Collaboration~Documents/Document") {
+            return [RichText, RichTextSnippet, RichTextDocument].filter(Boolean).map(makeUnit);
+        }
+        if (fieldObject.type === "comments/comment" && CommentsCollection) {
+            return [CommentsCollection].filter(Boolean).map(makeUnit);
+        }
+        if ((0, user_role_1.isUserRoleField)(fieldObject)) {
+            return [UserRole, UserRoleInput].filter(Boolean).map(makeUnit);
+        }
+        if (fieldObject.isHidden && !showHiddenFields) {
+            return [];
+        }
+        const unitsFactory = unitsFactoryByFieldKind[fieldObject.kind] || (0, constant_1.default)([]);
+        return (0, compact_1.default)(unitsFactory(fieldObject, options)).map(makeUnit);
+    };
+    const staticUnitsTypeOrder = [Id, AvatarCollection, TypeIcon, TypeBadge, TypeBadgeAbbr, Avatar, Title, UserButton]
+        .filter(Boolean)
+        .map(({ type }) => type);
+    function getTypeUnits() {
+        return [TypeIcon, TypeBadge, TypeBadgeAbbr].filter(Boolean).map((Unit) => Unit.makeUnit());
+    }
+    /**
+     * @returns flat list of all units for given type
+     */
+    function getUnitsForType(typeObject, options = {}) {
+        const collection = (0, flatMap_1.default)(typeObject.fieldObjects.filter((x) => !x.isHidden), (fieldObject) => getUnitsForField(fieldObject, options).map((unit) => ({ unit, fieldObject }))).concat(getTypeUnits().map((unit) => ({ unit, fieldObject: typeObject.titleFieldObject })));
+        return (0, sortBy_1.default)(collection, ({ unit }) => {
+            const index = staticUnitsTypeOrder.indexOf(unit.type);
+            return index === -1 ? staticUnitsTypeOrder.length : index;
+        });
+    }
+    /**
+     * @returns list of units grouped by field
+     */
+    function getUnitsForTypePerField(typeObject, options = {}) {
+        const collection = [];
+        for (const fieldObject of typeObject.fieldObjects) {
+            if (!fieldObject.isHidden) {
+                const units = getUnitsForField(fieldObject, options);
+                if (units.length > 0) {
+                    collection.push({
+                        fieldObject,
+                        units,
+                    });
+                }
+            }
+        }
+        return (0, sortBy_1.default)(collection, ({ units }) => {
+            return units
+                .map((unit) => {
+                const index = staticUnitsTypeOrder.indexOf(unit.type);
+                return index === -1 ? staticUnitsTypeOrder.length : index;
+            })
+                .sort((a, b) => a - b)[0];
+        });
+    }
+    const getHardcodedUnitsForView = (typeObject) => {
+        return [
+            TypeIcon && TypeIcon.makeUnit(),
+            Title && Title.makeUnit(),
+            ...getUnitsForField(typeObject.fieldObjectsByName["fibery/creation-date"]),
+            ...getUnitsForField(typeObject.fieldObjectsByName["fibery/container-app"]),
+            ...getUnitsForField(typeObject.fieldObjectsByName["fibery/container-entity-id"]),
+            ...getUnitsForField(typeObject.fieldObjectsByName["fibery/container-entity-type"]),
+        ].filter(Boolean);
+    };
+    const unitDefinitionsByTypeLookup = (0, mapValues_1.default)((0, groupBy_1.default)(allUnitDefinitions, (x) => x.type), (value) => (0, array_1.single)(value));
+    const getUnitLabel = (fieldObject, unit) => {
+        const unitDefinition = unitDefinitionsByTypeLookup[unit.type];
+        if (!unitDefinition) {
+            return "";
+        }
+        return unitDefinition.getLabel({ typeObject: fieldObject.holderTypeObject, unit: unit });
+    };
+    const getUnitName = (unit) => {
+        const unitDefinition = unitDefinitionsByTypeLookup[unit.type];
+        if (!unitDefinition) {
+            return null;
+        }
+        return unitDefinition.name;
+    };
+    const getUnitDataDefinition = (unit) => {
+        if (unitDefinitionsByTypeLookup[unit.type]) {
+            return unitDefinitionsByTypeLookup[unit.type];
+        }
+        // eslint-disable-next-line no-console
+        console.warn(`Unit Definition of type "${unit.type}" does not exist.`);
+        return not_found_1.NotFound;
+    };
+    const getCardUnitsSelect = ({ schema, typeObject, units }) => {
+        const selects = units
+            .filter((unit) => {
+            return ((0, common_1.isUnitEnabled)(unit) &&
+                unit.kind !== "user-button" &&
+                unit.expression?.[0] !== "documents/documents" &&
+                unit.expression?.[0] !== "whiteboards/whiteboards");
+        })
+            .map((unit) => {
+            const unitExpressionErrors = (0, common_1.calculateUnitExpressionErrors)({ typeObject, unit });
+            if (unitExpressionErrors.length > 0) {
+                return {};
+            }
+            const UnitDefinition = getUnitDataDefinition(unit);
+            const select = UnitDefinition.getQuerySelect({ schema, typeObject, unit: unit });
+            (0, trace_1.assert)((0, isPlainObject_1.default)(select), "getQuerySelect must return object-shaped select");
+            return select;
+        });
+        return (0, select_1.mergeDenormalizedSelects)(selects);
+    };
+    return {
+        getTypeUnits,
+        getUnitsForType,
+        getUnitsForTypePerField,
+        getUnitsForField,
+        getHardcodedUnitsForView,
+        getUnitLabel,
+        getUnitName,
+        getCardUnitsSelect,
+        getUnitDataDefinition,
+    };
+};
+exports.makeUnitDefinitionsFactory = makeUnitDefinitionsFactory;

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

@@ -0,0 +1,73 @@
+import { Schema, TypeObject } from "@fibery/schema";
+import { NumberDisplaySettings } from "../field-utils/number";
+import { $TSFixMe } from "../tsfixme";
+import { FiberyObject } from "@fibery/expression-utils/src/types";
+export type ButtonUnit = {
+    kind: "user-button";
+    type: "user-button" | "icon-button";
+    data: {
+        id: string;
+        typeId: string;
+    };
+    label: string;
+    checked?: boolean;
+    hideWhenEmpty?: boolean;
+    icon?: string;
+};
+export type UnitExpression = string[];
+export type DbUnit = {
+    kind: "db";
+    type: "type-icon" | "type-badge" | "type-badge-abbr";
+    expression?: UnitExpression;
+    checked?: boolean;
+    hideWhenEmpty?: boolean;
+};
+export type FieldUnit = {
+    kind: "field";
+    type: "avatar" | "avatar-collection" | "avatar-input" | "back-references-list" | "bool" | "bool-checkbox" | "collection-count" | "color-input" | "comments-list" | "date" | "date-time" | "date-time-combobox" | "date-range" | "date-range-combobox" | "email" | "email-input" | "emoji" | "field" | "files-gallery" | "files-list" | "files-list-item" | "files-l-list" | "files-l-list-item" | "file-reference" | "file-compact-collection" | "file-compact-reference" | "file-collection-count" | "geometry-preview" | "icon-button" | "icon-input" | "id" | "json-input" | "location" | "location-input" | "number" | "number-input" | "phone" | "phone-input" | "progress-bar" | "reference" | "reference-icon" | "reference-combobox" | "reference-collection" | "reference-collection-list" | "reference-collection-view" | "reference-collection-combobox" | "rich-text-snippet" | "rich-text-document" | "single-location-preview" | "text" | "text-input" | "title" | "title-input" | "url" | "url-input" | "user-role" | "user-role-input";
+    expression: UnitExpression;
+    checked?: boolean;
+    settings?: Record<string, unknown>;
+    hideWhenEmpty?: boolean;
+};
+export type Unit = FieldUnit | ButtonUnit | DbUnit;
+type ToPure<T extends Unit> = Omit<T, "checked">;
+export type PureUnit = ToPure<FieldUnit> | ToPure<ButtonUnit> | ToPure<DbUnit>;
+export type UnitDataDefinition<T extends Unit> = {
+    type: string;
+    name: string;
+    canEdit: (params: {
+        typeObject: TypeObject;
+        unit: T;
+    }) => boolean;
+    makeUnit: (params?: {
+        expression: UnitExpression;
+    }) => PureUnit;
+    getLabel: (params: {
+        typeObject: TypeObject;
+        unit: T;
+    }) => string;
+    getQuerySelect: (params: {
+        typeObject: TypeObject;
+        unit: T;
+        schema: Schema;
+    }) => $TSFixMe;
+    calculateErrors: (params: {
+        typeObject: TypeObject;
+        unit: T;
+    }) => $TSFixMe[];
+    getExportValue: (params: {
+        typeObject: TypeObject;
+        unit: T;
+        object: FiberyObject;
+        displaySettings: NumberDisplaySettings;
+    }) => unknown;
+    canExport: (params: {
+        unit: T;
+    }) => boolean;
+    getExportLabel?: (params: {
+        typeObject: TypeObject;
+        unit: T;
+    }) => string;
+};
+export {};

package/lib/src/units/types.js

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

package/package.json

@@ -1,77 +1,67 @@
 {
   "name": "@fibery/views",
-  "version": "17.0.4",
+  "version": "18.0.2",
   "description": "Operations on view objects",
   "license": "UNLICENSED",
   "author": "Fibery",
-  "main": "./lib/views.js",
-  "browser": "./index.js",
+  "main": "./lib/index.js",
+  "types": "./lib/index.d.ts",
   "files": [
     "/lib"
   ],
   "private": false,
+  "exports": {
+    ".": {
+      "types": "./lib/index.d.ts",
+      "default": "./lib/index.js"
+    },
+    "./src/*": {
+      "types": "./lib/src/*.d.ts",
+      "default": "./lib/src/*.js"
+    },
+    "./src/unit-definitions": {
+      "types": "./lib/src/unit-definitions/index.d.ts",
+      "default": "./lib/src/unit-definitions/index.js"
+    },
+    "./src/units/canvas": {
+      "types": "./lib/src/units/canvas/index.d.ts",
+      "default": "./lib/src/units/canvas/index.js"
+    }
+  },
+  "fiberyDevExports": {
+    ".": "./index.ts",
+    "./src/*": "./src/*"
+  },
+  "dependencies": {
+    "date-fns": "2.29.2",
+    "lodash": "4.17.21",
+    "moment": "2.29.4",
+    "@fibery/context-filters": "1.1.3",
+    "@fibery/expression-utils": "9.6.2",
+    "@fibery/schema": "10.2.13",
+    "@fibery/helpers": "1.4.0",
+    "@fibery/query-utils": "1.1.2"
+  },
   "devDependencies": {
     "@babel/core": "7.28.5",
     "@swc/jest": "0.2.39",
+    "@types/lodash": "4.14.172",
     "immutability-helper": "2.4.0",
     "jest": "30.2.0",
     "jest-junit": "16.0.0",
-    "lodash": "4.17.21",
-    "microbundle": "0.15.1",
+    "typescript": "5.9.3",
     "@fibery/babel-preset": "7.4.1",
-    "@fibery/expression-utils": "9.5.4",
-    "@fibery/eslint-config": "8.6.2",
-    "@fibery/schema": "10.2.9"
+    "@fibery/eslint-config": "9.0.0"
   },
   "peerDependencies": {
-    "@fibery/expression-utils": "^9.5.4",
-    "@fibery/schema": "^10.2.9",
+    "@fibery/expression-utils": "^9.6.2",
+    "@fibery/schema": "^10.2.13",
     "immutability-helper": "^2.4.0",
     "lodash": "4.17.21"
   },
-  "jest": {
-    "testEnvironment": "node",
-    "coveragePathIgnorePatterns": [
-      "/node_modules/"
-    ],
-    "collectCoverageFrom": [
-      "src/**/*.{js,jsx,ts,tsx}",
-      "!src/**/*.d.ts"
-    ],
-    "coverageReporters": [
-      "text",
-      "cobertura"
-    ],
-    "testPathIgnorePatterns": [
-      "<rootDir>[/\\\\](build|docs|node_modules|scripts)[/\\\\]"
-    ],
-    "transform": {
-      "^.+\\.(js|jsx|ts|tsx)$": [
-        "@swc/jest",
-        {
-          "jsc": {
-            "parser": {
-              "syntax": "typescript",
-              "tsx": true,
-              "decorators": true,
-              "dynamicImport": true
-            },
-            "transform": {
-              "react": {
-                "runtime": "automatic"
-              }
-            }
-          }
-        }
-      ]
-    },
-    "testEnvironmentOptions": {
-      "url": "http://localhost"
-    }
-  },
   "scripts": {
-    "build": "rm -rf lib && microbundle index.js -o lib -f cjs  --no-compress --target node --sourcemap false",
-    "test": "node scripts/test.js",
+    "build": "rm -rf lib && pnpm exec tsc --project tsconfig.build.json",
+    "test": "jest",
     "test:ci": "pnpm run test --reporters=default --reporters=jest-junit",
     "test:coverage": "pnpm run test --coverage --coverageDirectory=${JEST_COVERAGE_RESULT_DIR:-$(pwd)}/coverage/view  --reporters=default --reporters=jest-junit",
     "lint": "eslint ."