@alauda-fe/crd-form 0.0.1

package/esm2022/lib/utils/index.mjs

@@ -0,0 +1,7 @@
+export * from './capability';
+export * from './constant';
+export * from './directives';
+export * from './helper';
+export * from './service-model';
+export * from './util';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9saWJzL2NyZC1mb3JtL3NyYy9saWIvdXRpbHMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxjQUFjLENBQUM7QUFDN0IsY0FBYyxZQUFZLENBQUM7QUFDM0IsY0FBYyxjQUFjLENBQUM7QUFDN0IsY0FBYyxVQUFVLENBQUM7QUFDekIsY0FBYyxpQkFBaUIsQ0FBQztBQUNoQyxjQUFjLFFBQVEsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vY2FwYWJpbGl0eSc7XG5leHBvcnQgKiBmcm9tICcuL2NvbnN0YW50JztcbmV4cG9ydCAqIGZyb20gJy4vZGlyZWN0aXZlcyc7XG5leHBvcnQgKiBmcm9tICcuL2hlbHBlcic7XG5leHBvcnQgKiBmcm9tICcuL3NlcnZpY2UtbW9kZWwnO1xuZXhwb3J0ICogZnJvbSAnLi91dGlsJztcbiJdfQ==

package/esm2022/lib/utils/service-model.mjs

@@ -0,0 +1,12 @@
+export const NodeModel = {
+    apiVersion: 'v1',
+    label: 'Node',
+    labelKey: 'public~Node',
+    plural: 'nodes',
+    abbr: 'N',
+    kind: 'Node',
+    id: 'node',
+    labelPlural: 'Nodes',
+    labelPluralKey: 'public~Nodes',
+};
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/utils/util.mjs

@@ -0,0 +1,310 @@
+import { isEqual } from '@alauda-fe/common';
+import { find, flatMap, flatMapDepth, flatten, get, groupBy, isArray, map, parseInt, pick, reduce, sortBy, startCase, times, toPath, union, uniqWith, } from 'lodash-es';
+import { SpecCapability, SpecCapabilityUIPrefix, SpecCapabilityWidgetsPrefix, Validations, } from '../types';
+import { fieldShouldReveal, getBasicCapabilityType, getCapabilityDisabled, getCapabilityValidations, getDisplayByCapability, } from './capability';
+import { DESCRIPTOR_DEFINITION_KEY, GROUP_PATTERN, MAX_DEPTH, SCHEMA_PATH, } from './constant';
+import { getRelatedFields, getTreeFields, hasDescriptor, parseArrayPath, } from './helper';
+export function getPropertyDepth(property, depth = 0) {
+    if (!property || !['object', 'array'].includes(property.type)) {
+        return depth;
+    }
+    return Math.max(0, ...Object.values(property.properties || property.items?.properties || {}).map(nestedProperty => getPropertyDepth(nestedProperty, depth + 1)));
+}
+export function getFieldsFromDescriptor({ path, description, displayName, 'x-descriptors': capabilities = [], }, data, openApi, _originDescriptors) {
+    const { match, pathBeforeIndex, pathAfterIndex } = parseArrayPath(path);
+    const filedBasicType = getBasicCapabilityType(capabilities);
+    const disabled = getCapabilityDisabled(capabilities);
+    const validations = getCapabilityValidations(capabilities);
+    if (match) {
+        const n = get(data, toPath(`spec.${pathBeforeIndex}`), []).length || 1;
+        const pathAfterIndexStr = `.${pathAfterIndex}`;
+        let extra = [];
+        if (_originDescriptors) {
+            extra = flatten(_originDescriptors
+                .filter(d => d.path.startsWith(`${pathBeforeIndex}[0]`) && d.path !== path)
+                .map(d => times(n, index => {
+                const oPath = d.path.replace(`${pathBeforeIndex}[0]`, `${pathBeforeIndex}[${index}]`);
+                return {
+                    ...d,
+                    path: oPath,
+                };
+            }).slice(1)));
+        }
+        return flatten([
+            ...times(n, index => {
+                const propertyPath = `spec.${pathBeforeIndex}[${index}]${pathAfterIndex && pathAfterIndexStr}`;
+                const property = getOpenApiPropertyByPath(`spec.${path}`, openApi);
+                return {
+                    path: propertyPath,
+                    value: get(data, propertyPath),
+                    description,
+                    displayName,
+                    capabilities,
+                    type: filedBasicType || property?.type,
+                    required: null,
+                    disabled,
+                    validations: {
+                        ...validations,
+                        ...(property?.required && { required: true }),
+                    },
+                };
+            }),
+            ...extra.map(e => getFieldsFromDescriptor(e, data, openApi)),
+        ]);
+    }
+    // 通过 descriptor 查找原始 CRD 节点，推导类型、validation 等信息
+    const propertyPath = `spec.${path}`;
+    const property = getOpenApiPropertyByPath(propertyPath, openApi);
+    return [
+        {
+            path: propertyPath,
+            description,
+            displayName,
+            capabilities,
+            disabled,
+            value: get(data, propertyPath),
+            type: filedBasicType || property?.type,
+            required: null,
+            validations: {
+                ...validations,
+                ...(property?.required && { required: true }),
+            },
+        },
+    ];
+}
+export function getOpenApiPropertyByPath(descriptorPath, openApi) {
+    const paths = descriptorPath.split('.');
+    try {
+        return paths.reduce((acc, path) => {
+            acc = path.includes('[0]')
+                ? acc.items.properties[path.split('[0]')[0]]
+                : acc.properties[path];
+            return acc;
+        }, openApi);
+    }
+    catch {
+        return null;
+    }
+}
+export function getFieldsFromOpenApiSchema(openApi, descriptors, data, openApiSchemaPath = SCHEMA_PATH, maxDepth = MAX_DEPTH) {
+    const path = isArray(openApiSchemaPath)
+        ? openApiSchemaPath
+        : openApiSchemaPath.split('.').filter(Boolean);
+    const properties = get(openApi, [...path, 'properties'], {});
+    const required = get(openApi, [...path, 'required'], []);
+    return reduce(properties, (accumulator, _property, propertyName) => {
+        const property = _property;
+        if (!property.type || getPropertyDepth(property) > maxDepth) {
+            return accumulator;
+        }
+        return [
+            ...accumulator,
+            ...flattenNestedProperties(propertyName, property, descriptors, data, {
+                required: required.includes(propertyName),
+            }),
+        ];
+    }, []);
+}
+export function flattenNestedProperties(propertyName, property, descriptors, data, { currentCapabilities = [], currentPath = [], required = false, }) {
+    if (!property) {
+        return [];
+    }
+    const handleObjectProperty = () => flatMap(property.properties, (nestedProperty, nestedPropertyName) => flattenNestedProperties(nestedPropertyName, nestedProperty, descriptors, data, {
+        currentCapabilities: [
+            ...currentCapabilities,
+            `${SpecCapability.fieldGroup}${propertyName}`,
+        ],
+        currentPath: [...currentPath, propertyName],
+        required: (property.required || []).includes(nestedPropertyName),
+    }));
+    const handleArrayProperty = () => {
+        // Find the number of array elements that are already defined in the provided object
+        const n = get(data, `spec.${currentPath.join('.')}${propertyName}`, []).length || 1;
+        // Since _.times will return a multidimensional array of OperandFields (OperandField[][]), we
+        // need to flatten one level deeper than _.flatMap provides.
+        return flatMapDepth(property.items.properties, (nestedProperty, nestedPropertyName) => 
+        // Repeat recursion (n) times so that the correct number of fields are created for
+        // existing values in obj. This ensures that further nested fields also get created.
+        times(n, index => flattenNestedProperties(nestedPropertyName, nestedProperty, descriptors, data, {
+            currentCapabilities: [
+                ...currentCapabilities,
+                `${SpecCapability.arrayFieldGroup}${propertyName}`,
+            ],
+            currentPath: [...currentPath, `${propertyName}[${index}]`], // Array field paths must include an index
+            required: (property?.required || []).includes(nestedPropertyName),
+        })), 2);
+    };
+    const handleAtomicProperty = () => {
+        const path = [...currentPath, propertyName].join('.');
+        const descriptor = descriptors.find(item => item.path === modifyArrayFieldPathIndex(path, () => 0));
+        const capabilities = union(descriptor?.[DESCRIPTOR_DEFINITION_KEY] || [], currentCapabilities, getCapabilitiesForOpenApiProperty(property, descriptor?.[DESCRIPTOR_DEFINITION_KEY]));
+        const validations = getCapabilityValidations(capabilities);
+        const fieldPath = `spec.${path}`;
+        return [
+            {
+                path: fieldPath,
+                type: property.type,
+                required,
+                capabilities,
+                description: descriptor?.description || property.description,
+                displayName: descriptor?.displayName || startCase(propertyName),
+                validations: {
+                    ...pick(property, Object.keys(Validations)),
+                    ...validations,
+                },
+                value: get(data, fieldPath),
+            },
+        ];
+    };
+    switch (property.type) {
+        case 'object': {
+            return handleObjectProperty();
+        }
+        case 'array': {
+            return handleArrayProperty();
+        }
+        default: {
+            return handleAtomicProperty();
+        }
+    }
+}
+// Accepts an OpenAPI spec property and returns a corresponding SpecCapability[] array.
+export function getCapabilitiesForOpenApiProperty(property, capabilities = []) {
+    const formControlCapabilities = [
+        SpecCapabilityUIPrefix,
+        SpecCapabilityWidgetsPrefix,
+        SpecCapability.k8sResourcePrefix,
+    ];
+    if (capabilities.some(i => formControlCapabilities.some(k => i.startsWith(k)))) {
+        return [];
+    }
+    if (property.enum) {
+        return (property.enum || []).map((option) => `${SpecCapability.select}${option}`);
+    }
+    switch (property.type) {
+        case 'integer': {
+            return [SpecCapability.number];
+        }
+        case 'boolean': {
+            return [SpecCapability.booleanSwitch];
+        }
+        default: {
+            return [SpecCapability.text];
+        }
+    }
+}
+export function modifyArrayFieldPathIndex(path, operation) {
+    const { match, index, pathBeforeIndex, pathAfterIndex } = parseArrayPath(path);
+    const pathAfterIndexStr = `.${pathAfterIndex}`;
+    return match
+        ? `${pathBeforeIndex}[${operation(index)}]${pathAfterIndex && pathAfterIndexStr}`
+        : path;
+}
+export function pathToArray(path) {
+    return map(toPath(path), subPath => /^\d+$/.test(subPath) ? parseInt(subPath, 10) : subPath);
+}
+export function parseGroupDescriptor(field) {
+    const groupDescriptor = find(field.capabilities, descriptor => descriptor.startsWith(SpecCapability.fieldGroup) ||
+        descriptor.startsWith(SpecCapability.arrayFieldGroup));
+    const [match, groupType, groupName] = GROUP_PATTERN.exec(groupDescriptor) || [];
+    return { match, groupName, groupType };
+}
+export function normalizePath(path) {
+    return path?.startsWith('spec.') ? path : `spec.${path}`;
+}
+export function getFormData(formData, path, enableConvert = true) {
+    const value = formData.getIn(pathToArray(normalizePath(path)));
+    return enableConvert && value == null ? null : value;
+}
+export function createCapabilityField(descriptors = [], openApiSchema, data, openApiSchemaPath) {
+    const openApiFields = getFieldsFromOpenApiSchema(openApiSchema, descriptors, data, openApiSchemaPath);
+    const descriptorFields = uniqWith(reduce(descriptors, (accumulator, descriptor) => openApiFields?.some(field => field.path === `spec.${descriptor.path}`)
+        ? accumulator
+        : [
+            ...accumulator,
+            ...getFieldsFromDescriptor(descriptor, data, openApiSchema, descriptors),
+        ], []), isEqual);
+    const basicFields = [...openApiFields, ...descriptorFields];
+    const relationFields = getRelatedFields(basicFields.filter(fieldShouldReveal));
+    const treeFields = [
+        ...getTreeFields(relationFields.filter(f => !f.parent), relationFields.filter(f => !!f.parent)),
+        // 兼容老的数据结构
+        ...relationFields.filter(f => !f._dirty),
+    ];
+    // 保留，兼容老数据结构
+    const [advancedFields = [], arrayFields = [], groupFields = [], normalFields = [],] = reduce(treeFields, ([advancedFieldsAccumulator = [], arrayFieldsAccumulator = [], groupFieldsAccumulator = [], normalFieldsAccumulator = [],], field) => {
+        const mappers = [
+            { spec: SpecCapability.arrayFieldGroup, acc: arrayFieldsAccumulator },
+            { spec: SpecCapability.fieldGroup, acc: groupFieldsAccumulator },
+            { spec: SpecCapability.advanced, acc: advancedFieldsAccumulator },
+        ];
+        const acc = mappers.find(mapper => hasDescriptor(field, mapper.spec))?.acc;
+        return [
+            advancedFieldsAccumulator,
+            arrayFieldsAccumulator,
+            groupFieldsAccumulator,
+            normalFieldsAccumulator,
+        ].map(r => {
+            if ((!acc && r === normalFieldsAccumulator) || r === acc) {
+                return [...r, field];
+            }
+            return r;
+        });
+    }, []);
+    return {
+        normalFields: sortFields(normalFields, descriptors),
+        fieldGroups: sortGroupFields(groupFields, descriptors, descriptorFields),
+        arrayFieldGroups: getArrayFields(arrayFields, descriptorFields),
+        advancedFields: sortFields(advancedFields, descriptors),
+        descriptorFields,
+        openApiFields,
+        basicFields,
+        treeFields,
+    };
+}
+function getArrayFields(fields, descriptorFields) {
+    // array fields
+    const groupedArrayFieldsByName = groupBy(fields, field => {
+        const { groupName } = parseGroupDescriptor(field);
+        return groupName;
+    });
+    // Map {groupName: string, fieldLists: OperandField[][]}, where OperandField is a nested array
+    // of the appropriate fields, grouped by index.
+    return map(groupedArrayFieldsByName, (fieldsInGroup, groupName) => ({
+        groupName,
+        displayName: startCase(groupName),
+        capabilities: descriptorFields.find(field => field.path === `spec.${groupName}`)
+            ?.capabilities ?? [],
+        fieldLists: reduce(fieldsInGroup, (fieldListsAccumulator, field) => {
+            const { index, match } = parseArrayPath(field.path);
+            if (match) {
+                fieldListsAccumulator[index] = [
+                    ...(fieldListsAccumulator[index] || []),
+                    field,
+                ];
+            }
+            return fieldListsAccumulator;
+        }, []),
+        _dirty: false,
+    }));
+}
+function sortFields(fields, descriptors) {
+    return sortBy(fields, field => descriptors.findIndex(d => normalizePath(d.path) === normalizePath(field.path)));
+}
+function sortGroupFields(fields, descriptors, descriptorFields) {
+    const groupedFieldsByName = groupBy(sortFields(fields, descriptors), field => {
+        const { groupName } = parseGroupDescriptor(field);
+        return groupName;
+    });
+    return map(groupedFieldsByName, (fieldList, groupName) => ({
+        groupName,
+        displayName: startCase(groupName),
+        groupDisplay: fieldList
+            .map(field => getDisplayByCapability(field.capabilities, SpecCapability.fieldGroupName))
+            .find(d => !!d),
+        capabilities: descriptorFields.find(field => field.path === `spec.${groupName}`)
+            ?.capabilities ?? [],
+        fieldList,
+    }));
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"util.js","sourceRoot":"","sources":["../../../../../../libs/crd-form/src/lib/utils/util.ts"],"names":[],"mappings":"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","sourcesContent":["import { OpenAPIV3SchemaObject, isEqual } from '@alauda-fe/common';\nimport {\n  find,\n  flatMap,\n  flatMapDepth,\n  flatten,\n  get,\n  groupBy,\n  isArray,\n  map,\n  parseInt,\n  pick,\n  reduce,\n  sortBy,\n  startCase,\n  times,\n  toPath,\n  union,\n  uniqWith,\n} from 'lodash-es';\n\nimport {\n  Descriptor,\n  FormDataState,\n  OperandField,\n  OperandFieldValidation,\n  SpecCapability,\n  SpecCapabilityUIPrefix,\n  SpecCapabilityWidgetsPrefix,\n  Validations,\n} from '../types';\n\nimport {\n  fieldShouldReveal,\n  getBasicCapabilityType,\n  getCapabilityDisabled,\n  getCapabilityValidations,\n  getDisplayByCapability,\n} from './capability';\nimport {\n  DESCRIPTOR_DEFINITION_KEY,\n  GROUP_PATTERN,\n  MAX_DEPTH,\n  SCHEMA_PATH,\n} from './constant';\nimport {\n  getRelatedFields,\n  getTreeFields,\n  hasDescriptor,\n  parseArrayPath,\n} from './helper';\n\nexport interface FlattenNestedPropertiesAccumulator {\n  currentCapabilities?: SpecCapability[];\n  currentPath?: string[];\n  fields?: OperandField[];\n  required: boolean;\n}\n\nexport function getPropertyDepth(\n  property: OpenAPIV3SchemaObject,\n  depth = 0,\n): number {\n  if (!property || !['object', 'array'].includes(property.type)) {\n    return depth;\n  }\n  return Math.max(\n    0,\n    ...Object.values(\n      property.properties || property.items?.properties || {},\n    ).map(nestedProperty => getPropertyDepth(nestedProperty, depth + 1)),\n  );\n}\n\nexport function getFieldsFromDescriptor(\n  {\n    path,\n    description,\n    displayName,\n    'x-descriptors': capabilities = [],\n  }: Descriptor,\n  data: any,\n  openApi: OpenAPIV3SchemaObject,\n  _originDescriptors?: Descriptor[],\n): OperandField[] {\n  const { match, pathBeforeIndex, pathAfterIndex } = parseArrayPath(path);\n  const filedBasicType = getBasicCapabilityType(capabilities);\n  const disabled = getCapabilityDisabled(capabilities);\n  const validations = getCapabilityValidations(capabilities);\n  if (match) {\n    const n: number =\n      get(data, toPath(`spec.${pathBeforeIndex}`), []).length || 1;\n    const pathAfterIndexStr = `.${pathAfterIndex}`;\n    let extra: Descriptor[] = [];\n    if (_originDescriptors) {\n      extra = flatten(\n        _originDescriptors\n          .filter(\n            d => d.path.startsWith(`${pathBeforeIndex}[0]`) && d.path !== path,\n          )\n          .map(d =>\n            times(n, index => {\n              const oPath = d.path.replace(\n                `${pathBeforeIndex}[0]`,\n                `${pathBeforeIndex}[${index}]`,\n              );\n              return {\n                ...d,\n                path: oPath,\n              };\n            }).slice(1),\n          ),\n      );\n    }\n\n    return flatten([\n      ...times(n, index => {\n        const propertyPath = `spec.${pathBeforeIndex}[${index}]${\n          pathAfterIndex && pathAfterIndexStr\n        }`;\n        const property = getOpenApiPropertyByPath(`spec.${path}`, openApi);\n\n        return {\n          path: propertyPath,\n          value: get(data, propertyPath),\n          description,\n          displayName,\n          capabilities,\n          type: filedBasicType || property?.type,\n          required: null,\n          disabled,\n          validations: {\n            ...validations,\n            ...(property?.required && { required: true }),\n          },\n        };\n      }),\n      ...extra.map(e => getFieldsFromDescriptor(e, data, openApi)),\n    ]);\n  }\n  // 通过 descriptor 查找原始 CRD 节点，推导类型、validation 等信息\n  const propertyPath = `spec.${path}`;\n  const property = getOpenApiPropertyByPath(propertyPath, openApi);\n  return [\n    {\n      path: propertyPath,\n      description,\n      displayName,\n      capabilities,\n      disabled,\n      value: get(data, propertyPath),\n      type: filedBasicType || property?.type,\n      required: null,\n      validations: {\n        ...validations,\n        ...(property?.required && { required: true }),\n      },\n    },\n  ];\n}\n\nexport function getOpenApiPropertyByPath(\n  descriptorPath: string,\n  openApi: OpenAPIV3SchemaObject,\n) {\n  const paths = descriptorPath.split('.');\n  try {\n    return paths.reduce((acc, path) => {\n      acc = path.includes('[0]')\n        ? acc.items.properties[path.split('[0]')[0]]\n        : acc.properties[path];\n      return acc;\n    }, openApi);\n  } catch {\n    return null;\n  }\n}\n\nexport function getFieldsFromOpenApiSchema(\n  openApi: OpenAPIV3SchemaObject,\n  descriptors: Descriptor[],\n  data: unknown,\n  openApiSchemaPath: string | string[] = SCHEMA_PATH,\n  maxDepth = MAX_DEPTH,\n): OperandField[] {\n  const path = isArray(openApiSchemaPath)\n    ? openApiSchemaPath\n    : openApiSchemaPath.split('.').filter(Boolean);\n  const properties = get(openApi, [...path, 'properties'], {});\n  const required = get(openApi, [...path, 'required'], []) as string[];\n\n  return reduce(\n    properties,\n    (accumulator, _property, propertyName) => {\n      const property = _property as OpenAPIV3SchemaObject;\n      if (!property.type || getPropertyDepth(property) > maxDepth) {\n        return accumulator;\n      }\n\n      return [\n        ...accumulator,\n        ...flattenNestedProperties(propertyName, property, descriptors, data, {\n          required: required.includes(propertyName),\n        }),\n      ];\n    },\n    [],\n  );\n}\n\nexport function flattenNestedProperties(\n  propertyName: string,\n  property: OpenAPIV3SchemaObject,\n  descriptors: Descriptor[],\n  data: any,\n  {\n    currentCapabilities = [],\n    currentPath = [],\n    required = false,\n  }: FlattenNestedPropertiesAccumulator,\n) {\n  if (!property) {\n    return [];\n  }\n\n  const handleObjectProperty = (): OperandField[] =>\n    flatMap(property.properties, (nestedProperty, nestedPropertyName) =>\n      flattenNestedProperties(\n        nestedPropertyName,\n        nestedProperty,\n        descriptors,\n        data,\n        {\n          currentCapabilities: [\n            ...currentCapabilities,\n            `${SpecCapability.fieldGroup}${propertyName}` as SpecCapability,\n          ],\n          currentPath: [...currentPath, propertyName],\n          required: (property.required || []).includes(nestedPropertyName),\n        },\n      ),\n    );\n\n  const handleArrayProperty = (): OperandField[] => {\n    // Find the number of array elements that are already defined in the provided object\n    const n: number =\n      get(data, `spec.${currentPath.join('.')}${propertyName}`, []).length || 1;\n\n    // Since _.times will return a multidimensional array of OperandFields (OperandField[][]), we\n    // need to flatten one level deeper than _.flatMap provides.\n    return flatMapDepth(\n      property.items.properties,\n      (nestedProperty, nestedPropertyName) =>\n        // Repeat recursion (n) times so that the correct number of fields are created for\n        // existing values in obj. This ensures that further nested fields also get created.\n        times(n, index =>\n          flattenNestedProperties(\n            nestedPropertyName,\n            nestedProperty,\n            descriptors,\n            data,\n            {\n              currentCapabilities: [\n                ...currentCapabilities,\n                `${SpecCapability.arrayFieldGroup}${propertyName}` as SpecCapability,\n              ],\n              currentPath: [...currentPath, `${propertyName}[${index}]`], // Array field paths must include an index\n              required: (property?.required || []).includes(nestedPropertyName),\n            },\n          ),\n        ),\n      2,\n    );\n  };\n\n  const handleAtomicProperty = (): OperandField[] => {\n    const path = [...currentPath, propertyName].join('.');\n    const descriptor = descriptors.find(\n      item => item.path === modifyArrayFieldPathIndex(path, () => 0),\n    );\n    const capabilities = union(\n      descriptor?.[DESCRIPTOR_DEFINITION_KEY] || [],\n      currentCapabilities,\n      getCapabilitiesForOpenApiProperty(\n        property,\n        descriptor?.[DESCRIPTOR_DEFINITION_KEY],\n      ),\n    );\n    const validations = getCapabilityValidations(capabilities);\n    const fieldPath = `spec.${path}`;\n    return [\n      {\n        path: fieldPath,\n        type: property.type,\n        required,\n        capabilities,\n        description: descriptor?.description || property.description,\n        displayName: descriptor?.displayName || startCase(propertyName),\n        validations: {\n          ...(pick(\n            property,\n            Object.keys(Validations),\n          ) as unknown as OperandFieldValidation),\n          ...validations,\n        },\n        value: get(data, fieldPath),\n      },\n    ] as OperandField[];\n  };\n\n  switch (property.type) {\n    case 'object': {\n      return handleObjectProperty();\n    }\n    case 'array': {\n      return handleArrayProperty();\n    }\n    default: {\n      return handleAtomicProperty();\n    }\n  }\n}\n\n// Accepts an OpenAPI spec property and returns a corresponding SpecCapability[] array.\nexport function getCapabilitiesForOpenApiProperty(\n  property: OpenAPIV3SchemaObject,\n  capabilities: string[] = [],\n): SpecCapability[] {\n  const formControlCapabilities = [\n    SpecCapabilityUIPrefix,\n    SpecCapabilityWidgetsPrefix,\n    SpecCapability.k8sResourcePrefix,\n  ];\n  if (\n    capabilities.some(i => formControlCapabilities.some(k => i.startsWith(k)))\n  ) {\n    return [];\n  }\n  if (property.enum) {\n    return (property.enum || []).map(\n      (option: string) => `${SpecCapability.select}${option}` as SpecCapability,\n    );\n  }\n  switch (property.type) {\n    case 'integer': {\n      return [SpecCapability.number];\n    }\n    case 'boolean': {\n      return [SpecCapability.booleanSwitch];\n    }\n    default: {\n      return [SpecCapability.text];\n    }\n  }\n}\n\nexport function modifyArrayFieldPathIndex(\n  path: string,\n  operation: (index?: number) => string | number,\n): string {\n  const { match, index, pathBeforeIndex, pathAfterIndex } =\n    parseArrayPath(path);\n  const pathAfterIndexStr = `.${pathAfterIndex}`;\n  return match\n    ? `${pathBeforeIndex}[${operation(index)}]${\n        pathAfterIndex && pathAfterIndexStr\n      }`\n    : path;\n}\n\nexport function pathToArray(path: string): Array<string | number> {\n  return map(toPath(path), subPath =>\n    /^\\d+$/.test(subPath) ? parseInt(subPath, 10) : subPath,\n  );\n}\n\nexport function parseGroupDescriptor(field: OperandField): {\n  groupName?: string;\n  groupType?: string;\n  match?: string;\n} {\n  const groupDescriptor = find(\n    field.capabilities,\n    descriptor =>\n      descriptor.startsWith(SpecCapability.fieldGroup) ||\n      descriptor.startsWith(SpecCapability.arrayFieldGroup),\n  );\n  const [match, groupType, groupName] =\n    GROUP_PATTERN.exec(groupDescriptor) || [];\n  return { match, groupName, groupType };\n}\n\nexport function normalizePath(path: string) {\n  return path?.startsWith('spec.') ? path : `spec.${path}`;\n}\n\nexport function getFormData(\n  formData: FormDataState,\n  path: string,\n  enableConvert = true, // enable convert undefined => null\n) {\n  const value = formData.getIn(\n    pathToArray(normalizePath(path)),\n  ) as FormDataState;\n  return enableConvert && value == null ? null : value;\n}\n\nexport function createCapabilityField(\n  descriptors: Descriptor[] = [],\n  openApiSchema: OpenAPIV3SchemaObject,\n  data: unknown,\n  openApiSchemaPath: string | string[],\n) {\n  const openApiFields = getFieldsFromOpenApiSchema(\n    openApiSchema,\n    descriptors,\n    data,\n    openApiSchemaPath,\n  );\n\n  const descriptorFields: OperandField[] = uniqWith(\n    reduce(\n      descriptors,\n      (accumulator, descriptor) =>\n        openApiFields?.some(field => field.path === `spec.${descriptor.path}`)\n          ? accumulator\n          : [\n              ...accumulator,\n              ...getFieldsFromDescriptor(\n                descriptor,\n                data,\n                openApiSchema,\n                descriptors,\n              ),\n            ],\n      [],\n    ),\n    isEqual,\n  );\n  const basicFields = [...openApiFields, ...descriptorFields];\n\n  const relationFields = getRelatedFields(\n    basicFields.filter(fieldShouldReveal),\n  );\n\n  const treeFields = [\n    ...getTreeFields(\n      relationFields.filter(f => !f.parent),\n      relationFields.filter(f => !!f.parent),\n    ),\n    // 兼容老的数据结构\n    ...relationFields.filter(f => !f._dirty),\n  ] as OperandField[];\n\n  // 保留，兼容老数据结构\n  const [\n    advancedFields = [],\n    arrayFields = [],\n    groupFields = [],\n    normalFields = [],\n  ] = reduce(\n    treeFields,\n    (\n      [\n        advancedFieldsAccumulator = [] as OperandField[],\n        arrayFieldsAccumulator = [] as OperandField[],\n        groupFieldsAccumulator = [] as OperandField[],\n        normalFieldsAccumulator = [] as OperandField[],\n      ],\n      field: OperandField,\n    ) => {\n      const mappers = [\n        { spec: SpecCapability.arrayFieldGroup, acc: arrayFieldsAccumulator },\n        { spec: SpecCapability.fieldGroup, acc: groupFieldsAccumulator },\n        { spec: SpecCapability.advanced, acc: advancedFieldsAccumulator },\n      ];\n      const acc = mappers.find(mapper =>\n        hasDescriptor(field, mapper.spec),\n      )?.acc;\n      return [\n        advancedFieldsAccumulator,\n        arrayFieldsAccumulator,\n        groupFieldsAccumulator,\n        normalFieldsAccumulator,\n      ].map(r => {\n        if ((!acc && r === normalFieldsAccumulator) || r === acc) {\n          return [...r, field];\n        }\n        return r;\n      });\n    },\n    [],\n  );\n\n  return {\n    normalFields: sortFields(normalFields, descriptors),\n    fieldGroups: sortGroupFields(groupFields, descriptors, descriptorFields),\n    arrayFieldGroups: getArrayFields(arrayFields, descriptorFields),\n    advancedFields: sortFields(advancedFields, descriptors),\n    descriptorFields,\n    openApiFields,\n    basicFields,\n    treeFields,\n  };\n}\n\nfunction getArrayFields(\n  fields: OperandField[],\n  descriptorFields: OperandField[],\n) {\n  // array fields\n  const groupedArrayFieldsByName = groupBy(fields, field => {\n    const { groupName } = parseGroupDescriptor(field);\n    return groupName;\n  });\n\n  // Map {groupName: string, fieldLists: OperandField[][]}, where OperandField is a nested array\n  // of the appropriate fields, grouped by index.\n  return map(groupedArrayFieldsByName, (fieldsInGroup, groupName: string) => ({\n    groupName,\n    displayName: startCase(groupName),\n    capabilities:\n      descriptorFields.find(field => field.path === `spec.${groupName}`)\n        ?.capabilities ?? [],\n    fieldLists: reduce(\n      fieldsInGroup,\n      (fieldListsAccumulator, field) => {\n        const { index, match } = parseArrayPath(field.path);\n        if (match) {\n          fieldListsAccumulator[index] = [\n            ...(fieldListsAccumulator[index] || []),\n            field,\n          ];\n        }\n        return fieldListsAccumulator;\n      },\n      [] as OperandField[][],\n    ),\n    _dirty: false,\n  }));\n}\n\nfunction sortFields(fields: OperandField[], descriptors: Descriptor[]) {\n  return sortBy(fields, field =>\n    descriptors.findIndex(\n      d => normalizePath(d.path) === normalizePath(field.path),\n    ),\n  );\n}\n\nfunction sortGroupFields(\n  fields: OperandField[],\n  descriptors: Descriptor[],\n  descriptorFields: OperandField[],\n) {\n  const groupedFieldsByName = groupBy(\n    sortFields(fields, descriptors),\n    field => {\n      const { groupName } = parseGroupDescriptor(field);\n      return groupName;\n    },\n  );\n  return map(groupedFieldsByName, (fieldList, groupName) => ({\n    groupName,\n    displayName: startCase(groupName),\n    groupDisplay: fieldList\n      .map(field =>\n        getDisplayByCapability(\n          field.capabilities,\n          SpecCapability.fieldGroupName,\n        ),\n      )\n      .find(d => !!d),\n    capabilities:\n      descriptorFields.find(field => field.path === `spec.${groupName}`)\n        ?.capabilities ?? [],\n    fieldList,\n  }));\n}\n"]}

package/esm2022/public-api.mjs

@@ -0,0 +1,13 @@
+/*
+ * Public API Surface of crd-form
+ */
+export * from './lib/abstract/base-array';
+export * from './lib/crd-form.module';
+export * from './lib/crd-form/component';
+export * from './lib/field-controls';
+export * from './lib/field-widgets';
+export * from './lib/remote-widgets';
+export * from './lib/spec-descriptors';
+export * from './lib/types';
+export * from './lib/utils';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL2xpYnMvY3JkLWZvcm0vc3JjL3B1YmxpYy1hcGkudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7O0dBRUc7QUFFSCxjQUFjLDJCQUEyQixDQUFDO0FBQzFDLGNBQWMsdUJBQXVCLENBQUM7QUFDdEMsY0FBYywwQkFBMEIsQ0FBQztBQUN6QyxjQUFjLHNCQUFzQixDQUFDO0FBQ3JDLGNBQWMscUJBQXFCLENBQUM7QUFDcEMsY0FBYyxzQkFBc0IsQ0FBQztBQUNyQyxjQUFjLHdCQUF3QixDQUFDO0FBQ3ZDLGNBQWMsYUFBYSxDQUFDO0FBQzVCLGNBQWMsYUFBYSxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLypcbiAqIFB1YmxpYyBBUEkgU3VyZmFjZSBvZiBjcmQtZm9ybVxuICovXG5cbmV4cG9ydCAqIGZyb20gJy4vbGliL2Fic3RyYWN0L2Jhc2UtYXJyYXknO1xuZXhwb3J0ICogZnJvbSAnLi9saWIvY3JkLWZvcm0ubW9kdWxlJztcbmV4cG9ydCAqIGZyb20gJy4vbGliL2NyZC1mb3JtL2NvbXBvbmVudCc7XG5leHBvcnQgKiBmcm9tICcuL2xpYi9maWVsZC1jb250cm9scyc7XG5leHBvcnQgKiBmcm9tICcuL2xpYi9maWVsZC13aWRnZXRzJztcbmV4cG9ydCAqIGZyb20gJy4vbGliL3JlbW90ZS13aWRnZXRzJztcbmV4cG9ydCAqIGZyb20gJy4vbGliL3NwZWMtZGVzY3JpcHRvcnMnO1xuZXhwb3J0ICogZnJvbSAnLi9saWIvdHlwZXMnO1xuZXhwb3J0ICogZnJvbSAnLi9saWIvdXRpbHMnO1xuIl19

package/index.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Generated bundle index. Do not edit.
+ */
+/// <amd-module name="@alauda-fe/crd-form" />
+export * from './public-api';

package/lib/abstract/base-array.d.ts

@@ -0,0 +1,31 @@
+import { EventEmitter, OnChanges, SimpleChanges } from '@angular/core';
+import { CrdFormComponent } from '../crd-form/component';
+import { FieldValueChangeEvent, FormDataState, FormErrors, OperandArrayFieldGroup, OperandField } from '../types';
+import { getFieldDisplayName } from '../utils';
+import * as i0 from "@angular/core";
+export declare class BaseOperandFiledArrayComponent implements OnChanges {
+    readonly crdForm: CrdFormComponent;
+    arrayFieldGroup: OperandArrayFieldGroup;
+    formDataState: FormDataState;
+    formErrors: FormErrors;
+    isArrayTable: boolean;
+    readonly: boolean;
+    valueChange: EventEmitter<any>;
+    itemRemove: EventEmitter<any>;
+    private _expanded;
+    get expanded(): boolean;
+    set expanded(expanded: boolean);
+    basicArrayFieldTemplate: OperandField[];
+    getFieldDisplayName: typeof getFieldDisplayName;
+    constructor(crdForm: CrdFormComponent);
+    ngOnChanges({ arrayFieldGroup, formDataState }: SimpleChanges): void;
+    fieldValueChange(e: FieldValueChangeEvent): void;
+    addItem(): void;
+    removeItem(index: number): void;
+    private deleteFormData;
+    fieldIsRequired(field: OperandField): boolean;
+    get columnFields(): OperandField[];
+    trackByFn(index: number): number;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BaseOperandFiledArrayComponent, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<BaseOperandFiledArrayComponent, never, never, { "arrayFieldGroup": { "alias": "arrayFieldGroup"; "required": false; }; "formDataState": { "alias": "formDataState"; "required": false; }; "formErrors": { "alias": "formErrors"; "required": false; }; "isArrayTable": { "alias": "isArrayTable"; "required": false; }; "readonly": { "alias": "readonly"; "required": false; }; }, { "valueChange": "valueChange"; "itemRemove": "itemRemove"; }, never, never, false, never>;
+}

package/lib/crd-form/component.d.ts

@@ -0,0 +1,61 @@
+import { LabelPosition } from '@alauda/ui';
+import { OpenAPIV3SchemaObject } from '@alauda-fe/common';
+import { ComponentType } from '@angular/cdk/portal';
+import { EventEmitter, OnChanges, QueryList, SimpleChanges } from '@angular/core';
+import { AbstractControl, NgForm } from '@angular/forms';
+import { Observable } from 'rxjs';
+import { RemoteWidgetsService } from '../remote-widgets';
+import { Descriptor, FieldValueChangeEvent, FormDataState, FormErrors, FormState, OperandArrayFieldGroup, OperandField, OperandFieldGroup } from '../types';
+import { CrdFormCustomDescriptionDirective, getCustomDescription } from '../utils';
+import * as i0 from "@angular/core";
+export declare class CrdFormComponent implements OnChanges {
+    private readonly rws;
+    openApiSchema: OpenAPIV3SchemaObject;
+    descriptors: Descriptor[];
+    data: unknown;
+    debug: boolean;
+    openApiSchemaPath: string | string[];
+    readonly: boolean;
+    labelWidth: string;
+    labelPosition: LabelPosition;
+    cluster?: string;
+    namespace?: string;
+    formContext: any;
+    formContext$: Observable<any>;
+    keepEmptyPath: boolean;
+    effectControlDefaultValue: boolean;
+    uiContext?: Record<string, any>;
+    formStateChange: EventEmitter<FormState>;
+    formSchemaChange: EventEmitter<any>;
+    form: NgForm;
+    customDescriptions: QueryList<CrdFormCustomDescriptionDirective>;
+    widgets: Array<{
+        descriptor: string;
+        component: ComponentType<any>;
+    }>;
+    formDataState: FormDataState;
+    formErrors: FormErrors;
+    fields: OperandField[];
+    normalFields: OperandField[];
+    fieldGroups: OperandFieldGroup[];
+    arrayFieldGroups: OperandArrayFieldGroup[];
+    advancedFields: OperandField[];
+    private _lastUpdateField;
+    controlMap: Map<string, AbstractControl<any, any>>;
+    constructor(rws: RemoteWidgetsService);
+    remoteModuleDefinition$: Observable<import("../remote-widgets").RemoteWidgetModuleDefinition>;
+    ngOnChanges({ openApiSchema, descriptors, data }: SimpleChanges): void;
+    getCustomDescription: typeof getCustomDescription;
+    private setUpForm;
+    dirtyPathsSet: Set<string>;
+    fieldValueChange(event: FieldValueChangeEvent): void;
+    deleteFormData(path: string): void;
+    private updateValidPathValue;
+    private updateFormData;
+    refreshValidation(): void;
+    private resolveExpiredPath;
+    private initializeFormDataArrayProperty;
+    submit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CrdFormComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CrdFormComponent, "acl-crd-form", never, { "openApiSchema": { "alias": "openApiSchema"; "required": false; }; "descriptors": { "alias": "descriptors"; "required": false; }; "data": { "alias": "data"; "required": false; }; "debug": { "alias": "debug"; "required": false; }; "openApiSchemaPath": { "alias": "openApiSchemaPath"; "required": false; }; "readonly": { "alias": "readonly"; "required": false; }; "labelWidth": { "alias": "labelWidth"; "required": false; }; "labelPosition": { "alias": "labelPosition"; "required": false; }; "cluster": { "alias": "cluster"; "required": false; }; "namespace": { "alias": "namespace"; "required": false; }; "formContext": { "alias": "formContext"; "required": false; }; "keepEmptyPath": { "alias": "keepEmptyPath"; "required": false; }; "effectControlDefaultValue": { "alias": "effectControlDefaultValue"; "required": false; }; "uiContext": { "alias": "uiContext"; "required": false; }; "widgets": { "alias": "widgets"; "required": false; }; }, { "formStateChange": "formStateChange"; "formSchemaChange": "formSchemaChange"; }, ["customDescriptions"], never, false, never>;
+}

package/lib/crd-form/helper.d.ts

@@ -0,0 +1,7 @@
+import { OperandField } from '../types';
+export declare function differPathsTag(paths: string[], others: string[]): string[];
+export declare function getAllOtherTagPath(fields: OperandField[], paths: string[]): string[];
+export declare function matchValueAgainstOneOf(field: OperandField, currentValue: any): {
+    dirtyPaths: string[];
+    validPaths: string[];
+};

package/lib/crd-form.module.d.ts

@@ -0,0 +1,16 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./crd-form/component";
+import * as i2 from "./spec-descriptors/capability/capability.component";
+import * as i3 from "./spec-descriptors/capability-list/capability-list.component";
+import * as i4 from "./utils/directives";
+import * as i5 from "@alauda/ui";
+import * as i6 from "@alauda/code-editor";
+import * as i7 from "@angular/forms";
+import * as i8 from "@angular/common";
+import * as i9 from "@alauda-fe/common";
+import * as i10 from "./field-controls/module";
+export declare class CrdFormModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<CrdFormModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<CrdFormModule, [typeof i1.CrdFormComponent, typeof i2.SpecCapabilityComponent, typeof i3.SpecCapabilityListComponent, typeof i4.CrdFormCustomDescriptionDirective], [typeof i5.TooltipModule, typeof i5.ButtonModule, typeof i5.CheckboxModule, typeof i6.CodeEditorModule, typeof i5.DropdownModule, typeof i5.FormModule, typeof i5.IconModule, typeof i5.InputModule, typeof i5.RadioModule, typeof i5.SelectModule, typeof i5.SwitchModule, typeof i6.CodeEditorModule, typeof i7.FormsModule, typeof i7.ReactiveFormsModule, typeof i8.CommonModule, typeof i9.ArrayFormTableModule, typeof i9.ErrorsMapperModule, typeof i9.CoreModule, typeof i9.ValidatorsModule, typeof i9.TranslateModule, typeof i9.WidgetModule, typeof i5.TagModule, typeof i10.FieldControlsModule], [typeof i1.CrdFormComponent, typeof i2.SpecCapabilityComponent, typeof i3.SpecCapabilityListComponent, typeof i4.CrdFormCustomDescriptionDirective, typeof i10.FieldControlsModule]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<CrdFormModule>;
+}

package/lib/field-controls/expressions/expression-core.d.ts

@@ -0,0 +1,6 @@
+import { OperandField } from '../../types';
+import { PropsExpressions } from './props-expression';
+export interface FieldExpression<F extends OperandField = OperandField> {
+    expressions: Partial<PropsExpressions>;
+    evaluateExpressions?(field: F): void;
+}

package/lib/field-controls/expressions/props-expression.d.ts

@@ -0,0 +1,36 @@
+import { FormDataState, OperandField } from '../../types';
+import { FieldExpression } from './expression-core';
+export declare const EXPRESSION_PROPS_PREFIX = "urn:alm:descriptor:expression:props.";
+export declare const EXPRESSION_PROPS_OPTIONS_PREFIX = "urn:alm:descriptor:expression:props.options:";
+export declare const EXPRESSION_PROPS_DEFAULT_PREFIX = "urn:alm:descriptor:expression:props.default:";
+export declare const EXPRESSION_PROPS_HIDDEN_PREFIX = "urn:alm:descriptor:expression:props.hidden:";
+export declare const EXPRESSION_PROPS_ALLOW_CREATE_PREFIX = "urn:alm:descriptor:expression:props.allowCreate:";
+export interface PropsExpressions {
+    /**
+     * The form component options, such as select.
+     */
+    options?: OptionsExpressions;
+    /**
+     * The form component default value.
+     */
+    default?: string;
+    hidden?: string;
+    subscribedContextPaths: string[];
+    subscribedFormDataPaths: string[];
+}
+export interface OptionsExpressions {
+    api: string;
+    labelPath: string;
+    valuePath: string;
+    expression: string;
+}
+export declare class PropsFieldExpression implements FieldExpression {
+    expressions: PropsExpressions;
+    constructor(field: OperandField);
+    private evaluatePropsExpressions;
+    private evaluateOptionsExpression;
+    private evaluateCommonPropsExpression;
+    private evaluateSubscribedContextPaths;
+    private evaluateSubscribedFormDataPaths;
+}
+export declare const compareWithSubscribedPaths: (dynamicExpression: PropsExpressions, prev: [unknown, FormDataState], next: [unknown, FormDataState]) => boolean;

package/lib/field-controls/form-item.component.d.ts

@@ -0,0 +1,11 @@
+import { ChangeDetectorRef } from '@angular/core';
+import { OperandFieldComponent } from './operand-field.component';
+import * as i0 from "@angular/core";
+export declare class FormItemComponent {
+    readonly fieldComponent: OperandFieldComponent;
+    private readonly cdr;
+    plain: boolean;
+    constructor(fieldComponent: OperandFieldComponent, cdr: ChangeDetectorRef);
+    static ɵfac: i0.ɵɵFactoryDeclaration<FormItemComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FormItemComponent, "acl-crd-form-item", never, { "plain": { "alias": "plain"; "required": false; }; }, {}, never, ["*"], false, never>;
+}

package/lib/field-controls/index.d.ts

@@ -0,0 +1,7 @@
+export * from './form-item.component';
+export * from './module';
+export * from './operand-advanced-field-group.component';
+export * from './operand-array-field-group.component';
+export * from './operand-field.component';
+export * from './operand-field-group.component';
+export * from './widgets';