@openmfp/webcomponents 0.6.1 → 0.6.7

package/projects/ngx/declarative-ui/table/utils/field-definition.utils.spec.ts

@@ -1,70 +0,0 @@
-import { FieldDefinition } from '../../models';
-import { getFieldValue } from './field-definition.utils';
-
-describe('field-definition.utils', () => {
-  describe('getFieldValue', () => {
-    it('returns resource property value when resource is provided', () => {
-      const field: FieldDefinition = { property: 'name' };
-      expect(getFieldValue(field, { name: 'Alice' })).toBe('Alice');
-    });
-
-    it('returns nested property via jsonpath dot notation', () => {
-      const field: FieldDefinition = { property: 'metadata.name' };
-      expect(getFieldValue(field, { metadata: { name: 'test' } })).toBe('test');
-    });
-
-    it('returns empty string when property resolves to empty string', () => {
-      const field: FieldDefinition = {
-        property: 'metadata.name',
-        value: 'fallback',
-      };
-      expect(getFieldValue(field, { metadata: { name: '' } })).toBe('');
-    });
-
-    it('returns falsy value (false) over field.value fallback', () => {
-      const field: FieldDefinition = {
-        property: 'spec.enabled',
-        value: 'default',
-      };
-      expect(getFieldValue(field, { spec: { enabled: false } })).toBe(false);
-    });
-
-    it('falls back to field.value when resource property is undefined', () => {
-      const field: FieldDefinition = { property: 'missing', value: 'fallback' };
-      expect(getFieldValue(field, {})).toBe('fallback');
-    });
-
-    it('returns field.value when resource is undefined', () => {
-      const field: FieldDefinition = { property: 'name', value: 'static' };
-      expect(getFieldValue(field, undefined)).toBe('static');
-    });
-
-    it('returns undefined when field.value is undefined and resource is undefined', () => {
-      const field: FieldDefinition = { property: 'name' };
-      expect(getFieldValue(field, undefined)).toBeUndefined();
-    });
-
-    it('returns empty string field.value when resource is undefined', () => {
-      const field: FieldDefinition = { property: 'name', value: '' };
-      expect(getFieldValue(field, undefined)).toBe('');
-    });
-
-    it('returns complex object as field.value', () => {
-      const complexValue = { nested: { data: 'value' } };
-      const field: FieldDefinition = {
-        property: 'spec.config',
-        value: complexValue as unknown as string,
-      };
-      expect(getFieldValue(field, undefined)).toEqual(complexValue);
-    });
-
-    it('returns array as field.value', () => {
-      const arrayValue = ['item1', 'item2'];
-      const field: FieldDefinition = {
-        property: 'spec.items',
-        value: arrayValue as unknown as string,
-      };
-      expect(getFieldValue(field, undefined)).toEqual(arrayValue);
-    });
-  });
-});

package/projects/ngx/declarative-ui/table/utils/field-definition.utils.ts

@@ -1,13 +0,0 @@
-import { FieldDefinition } from '../../models';
-import { getResourceValueByJsonPath } from './resource-field-by-path';
-
-export function getFieldValue<T>(
-  field: FieldDefinition,
-  resource: T | undefined,
-) {
-  if (resource) {
-    return getResourceValueByJsonPath<T>(resource, field) ?? field.value;
-  }
-
-  return field.value;
-}

package/projects/ngx/declarative-ui/table/utils/proccess-fields.spec.ts

@@ -1,511 +0,0 @@
-import { processGroupFields } from './proccess-fields';
-import { TableFieldDefinition } from '../models';
-
-describe('proccess-fields', () => {
-  describe('processFields', () => {
-    it('should return empty array when input is empty', () => {
-      const result = processGroupFields([]);
-      expect(result).toEqual([]);
-    });
-
-    it('should return fields without groups unchanged', () => {
-      const fields: TableFieldDefinition[] = [
-        {
-          property: 'name',
-          label: 'Name',
-        },
-        {
-          property: 'age',
-          label: 'Age',
-        },
-      ];
-
-      const result = processGroupFields(fields);
-      expect(result).toEqual(fields);
-    });
-
-    it('should combine fields with the same group name', () => {
-      const fields: TableFieldDefinition[] = [
-        {
-          property: 'firstName',
-          label: 'First Name',
-          group: {
-            name: 'personalInfo',
-            label: 'Personal Information',
-          },
-        },
-        {
-          property: 'lastName',
-          label: 'Last Name',
-          group: {
-            name: 'personalInfo',
-            label: 'Personal Information',
-          },
-        },
-        {
-          property: 'email',
-          label: 'Email',
-          group: {
-            name: 'personalInfo',
-            label: 'Personal Information',
-          },
-        },
-      ];
-
-      const result = processGroupFields(fields);
-
-      expect(result).toHaveLength(1);
-      expect(result[0]).toEqual({
-        property: 'firstName',
-        label: 'First Name',
-        group: {
-          name: 'personalInfo',
-          label: 'Personal Information',
-          fields: [
-            { property: 'firstName', label: 'First Name' },
-            { property: 'lastName', label: 'Last Name' },
-            { property: 'email', label: 'Email' },
-          ],
-        },
-      });
-    });
-
-    it('should handle multiple different groups', () => {
-      const fields: TableFieldDefinition[] = [
-        {
-          property: 'firstName',
-          label: 'First Name',
-          group: {
-            name: 'personalInfo',
-            label: 'Personal Information',
-          },
-        },
-        {
-          property: 'lastName',
-          label: 'Last Name',
-          group: {
-            name: 'personalInfo',
-            label: 'Personal Information',
-          },
-        },
-        {
-          property: 'street',
-          label: 'Street',
-          group: {
-            name: 'address',
-            label: 'Address',
-          },
-        },
-        {
-          property: 'city',
-          label: 'City',
-          group: {
-            name: 'address',
-            label: 'Address',
-          },
-        },
-      ];
-
-      const result = processGroupFields(fields);
-
-      expect(result).toHaveLength(2);
-
-      const personalInfoField = result.find(
-        (f) => f.group?.name === 'personalInfo',
-      );
-      const addressField = result.find((f) => f.group?.name === 'address');
-
-      expect(personalInfoField).toEqual({
-        property: 'firstName',
-        label: 'First Name',
-        group: {
-          name: 'personalInfo',
-          label: 'Personal Information',
-          fields: [
-            { property: 'firstName', label: 'First Name' },
-            { property: 'lastName', label: 'Last Name' },
-          ],
-        },
-      });
-
-      expect(addressField).toEqual({
-        property: 'street',
-        label: 'Street',
-        group: {
-          name: 'address',
-          label: 'Address',
-          fields: [
-            { property: 'street', label: 'Street' },
-            { property: 'city', label: 'City' },
-          ],
-        },
-      });
-    });
-
-    it('should handle mixed fields with and without groups', () => {
-      const fields: TableFieldDefinition[] = [
-        {
-          property: 'id',
-          label: 'ID',
-        },
-        {
-          property: 'firstName',
-          label: 'First Name',
-          group: {
-            name: 'personalInfo',
-            label: 'Personal Information',
-          },
-        },
-        {
-          property: 'lastName',
-          label: 'Last Name',
-          group: {
-            name: 'personalInfo',
-            label: 'Personal Information',
-          },
-        },
-        {
-          property: 'status',
-          label: 'Status',
-        },
-      ];
-
-      const result = processGroupFields(fields);
-
-      expect(result).toHaveLength(3);
-
-      const idField = result.find((f) => f.property === 'id');
-      const statusField = result.find((f) => f.property === 'status');
-      const personalInfoField = result.find(
-        (f) => f.group?.name === 'personalInfo',
-      );
-
-      expect(idField).toEqual({
-        property: 'id',
-        label: 'ID',
-      });
-
-      expect(statusField).toEqual({
-        property: 'status',
-        label: 'Status',
-      });
-
-      expect(personalInfoField).toEqual({
-        property: 'firstName',
-        label: 'First Name',
-        group: {
-          name: 'personalInfo',
-          label: 'Personal Information',
-          fields: [
-            { property: 'firstName', label: 'First Name' },
-            { property: 'lastName', label: 'Last Name' },
-          ],
-        },
-      });
-    });
-
-    it('should use jsonPathExpression when available instead of property', () => {
-      const fields: TableFieldDefinition[] = [
-        {
-          property: 'firstName',
-          label: 'First Name',
-          jsonPathExpression: 'user.personal.firstName',
-          group: {
-            name: 'personalInfo',
-            label: 'Personal Information',
-          },
-        },
-        {
-          property: 'lastName',
-          label: 'Last Name',
-          jsonPathExpression: 'user.personal.lastName',
-          group: {
-            name: 'personalInfo',
-            label: 'Personal Information',
-          },
-        },
-        {
-          property: 'email',
-          label: 'Email',
-          group: {
-            name: 'personalInfo',
-            label: 'Personal Information',
-          },
-        },
-      ];
-
-      const result = processGroupFields(fields);
-
-      expect(result).toHaveLength(1);
-      expect(result[0].group?.fields).toEqual([
-        {
-          property: 'firstName',
-          label: 'First Name',
-          jsonPathExpression: 'user.personal.firstName',
-        },
-        {
-          property: 'lastName',
-          label: 'Last Name',
-          jsonPathExpression: 'user.personal.lastName',
-        },
-        { property: 'email', label: 'Email' },
-      ]);
-    });
-
-    it('should handle array properties', () => {
-      const fields: TableFieldDefinition[] = [
-        {
-          property: ['firstName', 'first_name'],
-          label: 'First Name',
-          group: {
-            name: 'personalInfo',
-            label: 'Personal Information',
-          },
-        },
-        {
-          property: ['lastName', 'last_name'],
-          label: 'Last Name',
-          group: {
-            name: 'personalInfo',
-            label: 'Personal Information',
-          },
-        },
-      ];
-
-      const result = processGroupFields(fields);
-
-      expect(result).toHaveLength(1);
-      expect(result[0].group?.fields).toEqual([
-        { property: ['firstName', 'first_name'], label: 'First Name' },
-        { property: ['lastName', 'last_name'], label: 'Last Name' },
-      ]);
-    });
-
-    it('should handle fields with group but no name', () => {
-      const fields: TableFieldDefinition[] = [
-        {
-          property: 'firstName',
-          label: 'First Name',
-          group: {
-            name: '',
-            label: 'Personal Information',
-          },
-        },
-        {
-          property: 'lastName',
-          label: 'Last Name',
-          group: {
-            name: 'personalInfo',
-            label: 'Personal Information',
-          },
-        },
-      ];
-
-      const result = processGroupFields(fields);
-
-      expect(result).toHaveLength(2);
-      expect(result[0]).toEqual({
-        property: 'firstName',
-        label: 'First Name',
-        group: {
-          name: '',
-          label: 'Personal Information',
-        },
-      });
-      expect(result[1]).toEqual({
-        property: 'lastName',
-        label: 'Last Name',
-        group: {
-          name: 'personalInfo',
-          label: 'Personal Information',
-          fields: [{ property: 'lastName', label: 'Last Name' }],
-        },
-      });
-    });
-
-    it('should handle fields with undefined group', () => {
-      const fields: TableFieldDefinition[] = [
-        {
-          property: 'firstName',
-          label: 'First Name',
-          group: undefined,
-        },
-        {
-          property: 'lastName',
-          label: 'Last Name',
-          group: {
-            name: 'personalInfo',
-            label: 'Personal Information',
-          },
-        },
-      ];
-
-      const result = processGroupFields(fields);
-
-      expect(result).toHaveLength(2);
-      expect(result[0]).toEqual({
-        property: 'firstName',
-        label: 'First Name',
-        group: undefined,
-      });
-      expect(result[1]).toEqual({
-        property: 'lastName',
-        label: 'Last Name',
-        group: {
-          name: 'personalInfo',
-          label: 'Personal Information',
-          fields: [{ property: 'lastName', label: 'Last Name' }],
-        },
-      });
-    });
-
-    it('should preserve all original field properties in the result', () => {
-      const fields = [
-        {
-          property: 'firstName',
-          label: 'First Name',
-          required: true,
-          values: ['John', 'Jane'],
-          group: {
-            name: 'personalInfo',
-            label: 'Personal Information',
-            delimiter: ' | ',
-          },
-          dynamicValuesDefinition: {
-            operation: 'query',
-            gqlQuery: 'query { users { name } }',
-            value: 'name',
-            key: 'id',
-          },
-        },
-        {
-          property: 'lastName',
-          label: 'Last Name',
-          required: false,
-          group: {
-            name: 'personalInfo',
-            label: 'Personal Information',
-            delimiter: ' | ',
-          },
-        },
-      ] as unknown as TableFieldDefinition[];
-
-      const result = processGroupFields(fields);
-
-      expect(result).toHaveLength(1);
-      expect(result[0]).toEqual({
-        property: 'firstName',
-        label: 'First Name',
-        required: true,
-        values: ['John', 'Jane'],
-        group: {
-          name: 'personalInfo',
-          label: 'Personal Information',
-          delimiter: ' | ',
-          fields: [
-            {
-              property: 'firstName',
-              label: 'First Name',
-              required: true,
-              values: ['John', 'Jane'],
-              dynamicValuesDefinition: {
-                operation: 'query',
-                gqlQuery: 'query { users { name } }',
-                value: 'name',
-                key: 'id',
-              },
-            },
-            {
-              property: 'lastName',
-              label: 'Last Name',
-              required: false,
-            },
-          ],
-        },
-        dynamicValuesDefinition: {
-          operation: 'query',
-          gqlQuery: 'query { users { name } }',
-          value: 'name',
-          key: 'id',
-        },
-      });
-    });
-
-    it('should handle complex nested group scenarios', () => {
-      const fields: TableFieldDefinition[] = [
-        {
-          property: 'id',
-          label: 'ID',
-        },
-        {
-          property: 'firstName',
-          label: 'First Name',
-          group: {
-            name: 'personalInfo',
-            label: 'Personal Information',
-          },
-        },
-        {
-          property: 'lastName',
-          label: 'Last Name',
-          group: {
-            name: 'personalInfo',
-            label: 'Personal Information',
-          },
-        },
-        {
-          property: 'street',
-          label: 'Street',
-          group: {
-            name: 'address',
-            label: 'Address',
-          },
-        },
-        {
-          property: 'city',
-          label: 'City',
-          group: {
-            name: 'address',
-            label: 'Address',
-          },
-        },
-        {
-          property: 'country',
-          label: 'Country',
-          group: {
-            name: 'address',
-            label: 'Address',
-          },
-        },
-        {
-          property: 'status',
-          label: 'Status',
-        },
-      ];
-
-      const result = processGroupFields(fields);
-
-      expect(result).toHaveLength(4);
-
-      const idField = result.find((f) => f.property === 'id');
-      const statusField = result.find((f) => f.property === 'status');
-      const personalInfoField = result.find(
-        (f) => f.group?.name === 'personalInfo',
-      );
-      const addressField = result.find((f) => f.group?.name === 'address');
-
-      expect(idField?.property).toBe('id');
-      expect(statusField?.property).toBe('status');
-
-      expect(personalInfoField?.group?.fields).toEqual([
-        { property: 'firstName', label: 'First Name' },
-        { property: 'lastName', label: 'Last Name' },
-      ]);
-      expect(addressField?.group?.fields).toEqual([
-        { property: 'street', label: 'Street' },
-        { property: 'city', label: 'City' },
-        { property: 'country', label: 'Country' },
-      ]);
-    });
-  });
-});

package/projects/ngx/declarative-ui/table/utils/proccess-fields.ts

@@ -1,71 +0,0 @@
-import { TableFieldDefinition } from '../models';
-
-type GroupBase = NonNullable<TableFieldDefinition['group']>;
-type ProcessedGroup = GroupBase & {
-  fields?: TableFieldDefinition[];
-};
-
-export type ProcessedTableFieldDefinition = Omit<TableFieldDefinition, 'group'> & {
-  group?: ProcessedGroup;
-};
-
-export const processGroupFields = (
-  fields: TableFieldDefinition[],
-): ProcessedTableFieldDefinition[] => {
-  return combineGroupFields(fields);
-};
-
-const collectGroupFields = (
-  fields: TableFieldDefinition[],
-): Record<string, TableFieldDefinition[]> => {
-  return fields.reduce(
-    (acc, f): Record<string, TableFieldDefinition[]> => {
-      if (!f.group?.name) {
-        return acc;
-      }
-
-      const key = f.group.name;
-      if (!acc[key]) {
-        acc[key] = [];
-      }
-
-      // Strip group information from the field when adding to the fields array
-      const { group, ...fieldWithoutGroup } = f;
-      acc[key].push(fieldWithoutGroup);
-      return acc;
-    },
-    {} as Record<string, TableFieldDefinition[]>,
-  );
-};
-
-const combineGroupFields = (fields: TableFieldDefinition[]): ProcessedTableFieldDefinition[] => {
-  const seenGroup = new Set<string>();
-  const groupFields = collectGroupFields(fields);
-  const result: ProcessedTableFieldDefinition[] = [];
-
-  fields.forEach((f) => {
-    if (!f.group?.name) {
-      result.push(f);
-      return;
-    }
-
-    const key = f.group.name;
-    if (seenGroup.has(key)) {
-      return;
-    }
-
-    seenGroup.add(key);
-
-    const grouped: ProcessedTableFieldDefinition = {
-      ...f,
-      group: {
-        ...f.group,
-        fields: groupFields[key],
-      },
-    };
-
-    result.push(grouped);
-  });
-
-  return result;
-};