@alauda-fe/crd-form 0.0.1

package/esm2022/lib/utils/capability.mjs

@@ -0,0 +1,295 @@
+import { FALSE, parseJSONStream, TRUE, parseJson, isJsonObjectString, } from '@alauda-fe/common';
+import { find, identity, isEmpty, last, set } from 'lodash-es';
+import { SpecCapability, Validations, } from '../types';
+import { DEFAULT_VALUE_PATTERN, DESCRIPTOR_DEFINITION_KEY, NamespacedResourceKind, REGEXP_K8S_RESOURCE_SUFFIX, REGEXP_VALIDATION_SUFFIX, } from './constant';
+import { coerceBoolean, coerceNumber } from './helper';
+export function getBasicAuthSecretConfig(field) {
+    const configPrefix = `${SpecCapability.basicAuthSecret}:`;
+    const capability = find(field.capabilities, descriptor => descriptor.startsWith(configPrefix));
+    if (!capability) {
+        return null;
+    }
+    const configStr = capability.slice(configPrefix.length);
+    return parseJSONStream(configStr)[0];
+}
+export function getRadioOptions(capabilities) {
+    const items = capabilities
+        .filter(c => c.startsWith(SpecCapability.radio))
+        .map(c => c.split(SpecCapability.radio)[1]);
+    return items
+        .filter(item => item.split(':').length === 1)
+        .map(item => {
+        const zhPrefix = `${item}:zh:`;
+        const enPrefix = `${item}:en:`;
+        const zhDescriptor = items.find(value => value.startsWith(zhPrefix));
+        const enDescriptor = items.find(value => value.startsWith(enPrefix));
+        return {
+            value: item,
+            display: {
+                zh: zhDescriptor ? zhDescriptor.split(zhPrefix)[1] : item,
+                en: enDescriptor ? enDescriptor.split(enPrefix)[1] : item,
+            },
+        };
+    });
+}
+export function setRadiosDefaultValue(descriptors) {
+    // Set radio default selected item
+    const defaultValueMap = (descriptors || [])
+        .filter(d => d[DESCRIPTOR_DEFINITION_KEY].some(item => item.startsWith(SpecCapability.radio)))
+        .map(item => ({
+        path: item.path,
+        value: item[DESCRIPTOR_DEFINITION_KEY].filter(c => c.startsWith(SpecCapability.radio))
+            .map(c => c.split(SpecCapability.radio)[1])
+            .find(c => c.split(':').length === 1),
+    }))
+        .reduce((acc, cur) => ({
+        ...set(acc, cur.path, cur.value),
+    }), {});
+    return {
+        spec: {
+            ...defaultValueMap,
+        },
+    };
+}
+export const getBooleanSwitchOptions = (capabilities) => {
+    const items = capabilities
+        .filter(c => c.startsWith(SpecCapability.booleanSwitch))
+        .map(c => c.split(SpecCapability.booleanSwitch)[1]);
+    return [TRUE, FALSE].map(item => {
+        const zhPrefix = `:${item}:zh:`;
+        const enPrefix = `:${item}:en:`;
+        const zhDescriptor = items.find(value => value.startsWith(zhPrefix));
+        const enDescriptor = items.find(value => value.startsWith(enPrefix));
+        return {
+            value: item,
+            display: zhDescriptor && enDescriptor
+                ? {
+                    zh: zhDescriptor ? zhDescriptor.split(zhPrefix)[1] : item,
+                    en: enDescriptor ? enDescriptor.split(enPrefix)[1] : item,
+                }
+                : item === TRUE
+                    ? 'yes'
+                    : 'no',
+        };
+    });
+};
+export const convertBooleanSwitchValue = (value, capabilities) => {
+    const options = getBooleanSwitchOptions(capabilities);
+    return options.find(item => item.value === (value ? TRUE : FALSE))?.display;
+};
+export function convertValue(value, type) {
+    switch (type) {
+        case 'number':
+        case 'integer': {
+            return coerceNumber(value);
+        }
+        case 'boolean': {
+            return coerceBoolean(value);
+        }
+        default: {
+            // 兼容 value 为 json 字符串的情况
+            return isJsonObjectString(value)
+                ? parseJson(value, value)
+                : value || undefined;
+        }
+    }
+}
+export function getDefaultValue(field) {
+    const defaultValueDescriptor = find(field.capabilities, descriptor => descriptor.startsWith(SpecCapability.defaultValue));
+    if (defaultValueDescriptor) {
+        const [, value] = DEFAULT_VALUE_PATTERN.exec(defaultValueDescriptor) || [];
+        return convertValue(value, field.type);
+    }
+}
+const UI_FIELDS = [
+    SpecCapability.text,
+    {
+        spec: `${SpecCapability.text}:link`,
+        refer: SpecCapability.text,
+    },
+    {
+        spec: `${SpecCapability.text}:link:`,
+        prefix: true,
+    },
+    SpecCapability.password,
+    SpecCapability.confirmPassword,
+    SpecCapability.externalPassword,
+    SpecCapability.number,
+    SpecCapability.textarea,
+    {
+        spec: SpecCapability.podCount,
+        refer: SpecCapability.number,
+    },
+    SpecCapability.booleanSwitch,
+    {
+        spec: SpecCapability.select,
+        prefix: true,
+    },
+    SpecCapability.resourceRequirements,
+    SpecCapability.yaml,
+    SpecCapability.object,
+    SpecCapability.array,
+    {
+        spec: SpecCapability.radio,
+        prefix: true,
+    },
+    {
+        spec: SpecCapability.k8sResourcePrefix,
+        prefix: true,
+    },
+    {
+        spec: SpecCapability.basicAuthSecret,
+        prefix: true,
+    },
+    {
+        spec: SpecCapability.custom,
+        prefix: true,
+    },
+    {
+        spec: SpecCapability.remote,
+        prefix: true,
+    },
+    {
+        spec: SpecCapability.tagsInput,
+        prefix: true,
+    },
+];
+export function getFieldType(field) {
+    const { capabilities } = field;
+    const result = UI_FIELDS.find(specField => {
+        if (typeof specField === 'string') {
+            return capabilities.includes(specField);
+        }
+        return specField.prefix
+            ? capabilities.some(c => c.startsWith(specField.spec))
+            : capabilities.includes(specField.spec);
+    });
+    return typeof result === 'string' ? result : result?.refer ?? result?.spec;
+}
+export function getBasicCapabilityType(capabilities) {
+    if (capabilities.includes(SpecCapability.text)) {
+        return 'string';
+    }
+    if (capabilities.includes(SpecCapability.number) ||
+        capabilities.includes(SpecCapability.podCount)) {
+        return 'number';
+    }
+    if (capabilities.includes(SpecCapability.booleanSwitch)) {
+        return 'boolean';
+    }
+    if (capabilities.includes(SpecCapability.object)) {
+        return 'object';
+    }
+    if (capabilities.includes(SpecCapability.array)) {
+        return 'array';
+    }
+}
+function getFieldNameByLabel(field, label) {
+    const descriptor = find(field?.capabilities, descriptor => descriptor.startsWith(label));
+    return descriptor
+        ? descriptor.split(label)[1]
+        : 'displayName' in field
+            ? field.displayName
+            : null;
+}
+export function getFieldDisplayName(field) {
+    const en = getFieldNameByLabel(field, SpecCapability.labelEn);
+    const zh = getFieldNameByLabel(field, SpecCapability.labelZh);
+    return (en || zh) && { en, zh };
+}
+export function getDisplayByCapability(capabilities, name, fallback) {
+    const enDes = `${name}en:`;
+    const zhDes = `${name}zh:`;
+    const en = find(capabilities, descriptor => descriptor.startsWith(enDes))?.split(enDes)?.[1];
+    const zh = find(capabilities, descriptor => descriptor.startsWith(zhDes))?.split(zhDes)?.[1];
+    return en || zh
+        ? { en: en || zh || fallback, zh: zh || en || fallback }
+        : fallback
+            ? { en: fallback, zh: fallback }
+            : null;
+}
+export function getFieldDescription(field) {
+    const enDescriptor = find(field.capabilities, descriptor => descriptor.startsWith(SpecCapability.descriptionEn));
+    const zhDescriptor = find(field.capabilities, descriptor => descriptor.startsWith(SpecCapability.descriptionZh));
+    return {
+        en: enDescriptor
+            ? enDescriptor.split(SpecCapability.descriptionEn)[1]
+            : field.description,
+        zh: zhDescriptor
+            ? zhDescriptor.split(SpecCapability.descriptionZh)[1]
+            : field.description,
+    };
+}
+// cspell:disable-next-line
+// k8s params should conform to urn:alm:descriptor:io.kubernetes:Secret?=isGlobal=true:labelSelector=plugins.cpaas.io%2Fvictoriametrics%3Dtrue
+// : is used by dividing meta params and queryParams,both should be url encoded(percent encoding)
+const K8S_RESOURCE_META_PARAMS_DIVIDER = ':';
+export function getK8sResourcePrefixOptions(field) {
+    const capability = find(field.capabilities, descriptor => descriptor.startsWith(SpecCapability.k8sResourcePrefix));
+    const multiple = field.capabilities.some(descriptor => descriptor.startsWith(SpecCapability.multiple));
+    const validations = getCapabilityValidations(field.capabilities);
+    const [, resource, , qComponents] = capability.match(REGEXP_K8S_RESOURCE_SUFFIX) ?? [];
+    const groupVersionKind = resource?.replace(/:/g, '~');
+    const kind = last(groupVersionKind.split('~'));
+    const [metaStr, queryParamsStr] = (qComponents ?? '').split(K8S_RESOURCE_META_PARAMS_DIVIDER);
+    const meta = resolveKVParams(metaStr);
+    const queryParams = resolveKVParams(queryParamsStr);
+    return {
+        namespaced: NamespacedResourceKind.includes(kind),
+        labelSelector: queryParams.labelSelector,
+        isGlobal: !!meta.isGlobal,
+        groupVersionKind, // 现有的 apiversion，apiGroup 皆由环境配置，可以暂时不用
+        type: last(groupVersionKind.split('~')),
+        multiple,
+        validations,
+    };
+}
+// resolve a=b&c=d 格式数据
+export function resolveKVParams(str) {
+    return (str || '')
+        .split('&')
+        .filter(i => !isEmpty(i))
+        .reduce((acc, curr) => {
+        const [k, v] = curr.split('=');
+        acc[k] = decodeURIComponent(v);
+        return acc;
+    }, {});
+}
+export function getCapabilityDisabled(capabilities) {
+    return capabilities.includes(SpecCapability.disabled);
+}
+export function getCapabilityValidations(capabilities) {
+    const validations = capabilities?.filter(c => c.startsWith(SpecCapability.validation));
+    return validations.reduce((acc, descriptor) => {
+        const [, validation, param] = descriptor.match(REGEXP_VALIDATION_SUFFIX) ?? [];
+        if (!validation) {
+            return acc;
+        }
+        if (validation === Validations.pattern) {
+            acc[validation] = param;
+        }
+        else if (validation === Validations.required) {
+            acc[validation] = Boolean(param);
+        }
+        else {
+            acc[validation] = +param;
+        }
+        return acc;
+    }, {});
+}
+export function getOneOfMap(field) {
+    const map = {};
+    const capabilities = field.capabilities.filter(c => c.startsWith(SpecCapability.oneOf));
+    capabilities.forEach(c => {
+        const str = c.split(SpecCapability.oneOf)[1];
+        // 这里 path 与后端约束直接支持 path@tag 模式
+        const [value, ...path] = str.split(':');
+        map[value] = [...path];
+    });
+    return map;
+}
+export function fieldShouldReveal(field) {
+    return (!field.capabilities.includes(SpecCapability.hidden) &&
+        identity(getFieldType(field)));
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"capability.js","sourceRoot":"","sources":["../../../../../../libs/crd-form/src/lib/utils/capability.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  Dictionary,\n  FALSE,\n  JSONSchema6TypeName,\n  parseJSONStream,\n  StringMap,\n  TRUE,\n  parseJson,\n  isJsonObjectString,\n} from '@alauda-fe/common';\nimport { find, identity, isEmpty, last, set } from 'lodash-es';\n\nimport {\n  Descriptor,\n  OperandArrayFieldGroup,\n  OperandField,\n  OperandFieldGroup,\n  OperandFieldValidation,\n  SpecCapability,\n  Validations,\n} from '../types';\n\nimport {\n  DEFAULT_VALUE_PATTERN,\n  DESCRIPTOR_DEFINITION_KEY,\n  NamespacedResourceKind,\n  REGEXP_K8S_RESOURCE_SUFFIX,\n  REGEXP_VALIDATION_SUFFIX,\n} from './constant';\nimport { coerceBoolean, coerceNumber } from './helper';\n\nexport function getBasicAuthSecretConfig(field: OperandField) {\n  const configPrefix = `${SpecCapability.basicAuthSecret}:`;\n  const capability = find(field.capabilities, descriptor =>\n    descriptor.startsWith(configPrefix),\n  );\n  if (!capability) {\n    return null;\n  }\n  const configStr = capability.slice(configPrefix.length);\n  return parseJSONStream(configStr)[0];\n}\n\nexport function getRadioOptions(capabilities: SpecCapability[]) {\n  const items = capabilities\n    .filter(c => c.startsWith(SpecCapability.radio))\n    .map(c => c.split(SpecCapability.radio)[1]);\n  return items\n    .filter(item => item.split(':').length === 1)\n    .map(item => {\n      const zhPrefix = `${item}:zh:`;\n      const enPrefix = `${item}:en:`;\n      const zhDescriptor = items.find(value => value.startsWith(zhPrefix));\n      const enDescriptor = items.find(value => value.startsWith(enPrefix));\n      return {\n        value: item,\n        display: {\n          zh: zhDescriptor ? zhDescriptor.split(zhPrefix)[1] : item,\n          en: enDescriptor ? enDescriptor.split(enPrefix)[1] : item,\n        },\n      };\n    });\n}\n\nexport function setRadiosDefaultValue(descriptors: Descriptor[]) {\n  // Set radio default selected item\n  const defaultValueMap = (descriptors || [])\n    .filter(d =>\n      d[DESCRIPTOR_DEFINITION_KEY].some(item =>\n        item.startsWith(SpecCapability.radio),\n      ),\n    )\n    .map(item => ({\n      path: item.path,\n      value: item[DESCRIPTOR_DEFINITION_KEY].filter(c =>\n        c.startsWith(SpecCapability.radio),\n      )\n        .map(c => c.split(SpecCapability.radio)[1])\n        .find(c => c.split(':').length === 1),\n    }))\n    .reduce(\n      (acc, cur) => ({\n        ...set(acc, cur.path, cur.value),\n      }),\n      {},\n    );\n  return {\n    spec: {\n      ...defaultValueMap,\n    },\n  };\n}\n\nexport const getBooleanSwitchOptions = (capabilities: SpecCapability[]) => {\n  const items = capabilities\n    .filter(c => c.startsWith(SpecCapability.booleanSwitch))\n    .map(c => c.split(SpecCapability.booleanSwitch)[1]);\n\n  return [TRUE, FALSE].map(item => {\n    const zhPrefix = `:${item}:zh:`;\n    const enPrefix = `:${item}:en:`;\n    const zhDescriptor = items.find(value => value.startsWith(zhPrefix));\n    const enDescriptor = items.find(value => value.startsWith(enPrefix));\n    return {\n      value: item,\n      display:\n        zhDescriptor && enDescriptor\n          ? {\n              zh: zhDescriptor ? zhDescriptor.split(zhPrefix)[1] : item,\n              en: enDescriptor ? enDescriptor.split(enPrefix)[1] : item,\n            }\n          : item === TRUE\n          ? 'yes'\n          : 'no',\n    };\n  });\n};\n\nexport const convertBooleanSwitchValue = (\n  value: boolean,\n  capabilities: SpecCapability[],\n) => {\n  const options = getBooleanSwitchOptions(capabilities);\n  return options.find(item => item.value === (value ? TRUE : FALSE))?.display;\n};\n\nexport function convertValue(value: string, type: JSONSchema6TypeName) {\n  switch (type) {\n    case 'number':\n    case 'integer': {\n      return coerceNumber(value);\n    }\n    case 'boolean': {\n      return coerceBoolean(value);\n    }\n    default: {\n      // 兼容 value 为 json 字符串的情况\n      return isJsonObjectString(value)\n        ? parseJson(value, value)\n        : value || undefined;\n    }\n  }\n}\n\nexport function getDefaultValue(field: OperandField) {\n  const defaultValueDescriptor = find(field.capabilities, descriptor =>\n    descriptor.startsWith(SpecCapability.defaultValue),\n  );\n  if (defaultValueDescriptor) {\n    const [, value] = DEFAULT_VALUE_PATTERN.exec(defaultValueDescriptor) || [];\n    return convertValue(value, field.type);\n  }\n}\n\nconst UI_FIELDS: Array<\n  | SpecCapability\n  | { spec: SpecCapability; refer?: SpecCapability; prefix?: boolean }\n> = [\n  SpecCapability.text,\n  {\n    spec: `${SpecCapability.text}:link` as SpecCapability,\n    refer: SpecCapability.text,\n  },\n  {\n    spec: `${SpecCapability.text}:link:` as SpecCapability,\n    prefix: true,\n  },\n  SpecCapability.password,\n  SpecCapability.confirmPassword,\n  SpecCapability.externalPassword,\n  SpecCapability.number,\n  SpecCapability.textarea,\n  {\n    spec: SpecCapability.podCount,\n    refer: SpecCapability.number,\n  },\n  SpecCapability.booleanSwitch,\n  {\n    spec: SpecCapability.select,\n    prefix: true,\n  },\n  SpecCapability.resourceRequirements,\n  SpecCapability.yaml,\n  SpecCapability.object,\n  SpecCapability.array,\n  {\n    spec: SpecCapability.radio,\n    prefix: true,\n  },\n  {\n    spec: SpecCapability.k8sResourcePrefix,\n    prefix: true,\n  },\n  {\n    spec: SpecCapability.basicAuthSecret,\n    prefix: true,\n  },\n  {\n    spec: SpecCapability.custom,\n    prefix: true,\n  },\n  {\n    spec: SpecCapability.remote,\n    prefix: true,\n  },\n  {\n    spec: SpecCapability.tagsInput,\n    prefix: true,\n  },\n];\n\nexport function getFieldType(field: OperandField): SpecCapability {\n  const { capabilities } = field;\n  const result = UI_FIELDS.find(specField => {\n    if (typeof specField === 'string') {\n      return capabilities.includes(specField);\n    }\n    return specField.prefix\n      ? capabilities.some(c => c.startsWith(specField.spec))\n      : capabilities.includes(specField.spec);\n  });\n  return typeof result === 'string' ? result : result?.refer ?? result?.spec;\n}\n\nexport function getBasicCapabilityType(capabilities: string[]) {\n  if (capabilities.includes(SpecCapability.text)) {\n    return 'string';\n  }\n  if (\n    capabilities.includes(SpecCapability.number) ||\n    capabilities.includes(SpecCapability.podCount)\n  ) {\n    return 'number';\n  }\n  if (capabilities.includes(SpecCapability.booleanSwitch)) {\n    return 'boolean';\n  }\n  if (capabilities.includes(SpecCapability.object)) {\n    return 'object';\n  }\n  if (capabilities.includes(SpecCapability.array)) {\n    return 'array';\n  }\n}\n\nfunction getFieldNameByLabel(\n  field: OperandField | OperandArrayFieldGroup | OperandFieldGroup,\n  label: SpecCapability.labelEn | SpecCapability.labelZh,\n) {\n  const descriptor = find(field?.capabilities, descriptor =>\n    descriptor.startsWith(label),\n  );\n  return descriptor\n    ? descriptor.split(label)[1]\n    : 'displayName' in field\n    ? field.displayName\n    : null;\n}\n\nexport function getFieldDisplayName(\n  field: OperandField | OperandArrayFieldGroup | OperandFieldGroup,\n) {\n  const en = getFieldNameByLabel(field, SpecCapability.labelEn);\n  const zh = getFieldNameByLabel(field, SpecCapability.labelZh);\n\n  return (en || zh) && { en, zh };\n}\n\nexport function getDisplayByCapability(\n  capabilities: SpecCapability[],\n  name: string,\n  fallback?: string,\n) {\n  const enDes = `${name}en:`;\n  const zhDes = `${name}zh:`;\n  const en = find(capabilities, descriptor =>\n    descriptor.startsWith(enDes),\n  )?.split(enDes)?.[1];\n  const zh = find(capabilities, descriptor =>\n    descriptor.startsWith(zhDes),\n  )?.split(zhDes)?.[1];\n  return en || zh\n    ? { en: en || zh || fallback, zh: zh || en || fallback }\n    : fallback\n    ? { en: fallback, zh: fallback }\n    : null;\n}\n\nexport function getFieldDescription(field: OperandField) {\n  const enDescriptor = find(field.capabilities, descriptor =>\n    descriptor.startsWith(SpecCapability.descriptionEn),\n  );\n  const zhDescriptor = find(field.capabilities, descriptor =>\n    descriptor.startsWith(SpecCapability.descriptionZh),\n  );\n  return {\n    en: enDescriptor\n      ? enDescriptor.split(SpecCapability.descriptionEn)[1]\n      : field.description,\n    zh: zhDescriptor\n      ? zhDescriptor.split(SpecCapability.descriptionZh)[1]\n      : field.description,\n  };\n}\n\n// cspell:disable-next-line\n// k8s params should conform to urn:alm:descriptor:io.kubernetes:Secret?=isGlobal=true:labelSelector=plugins.cpaas.io%2Fvictoriametrics%3Dtrue\n// : is used by dividing meta params and queryParams,both should be url encoded(percent encoding)\nconst K8S_RESOURCE_META_PARAMS_DIVIDER = ':';\n\nexport function getK8sResourcePrefixOptions(field: OperandField) {\n  const capability = find(field.capabilities, descriptor =>\n    descriptor.startsWith(SpecCapability.k8sResourcePrefix),\n  );\n  const multiple = field.capabilities.some(descriptor =>\n    descriptor.startsWith(SpecCapability.multiple),\n  );\n  const validations = getCapabilityValidations(field.capabilities);\n  const [, resource, , qComponents] =\n    capability.match(REGEXP_K8S_RESOURCE_SUFFIX) ?? [];\n  const groupVersionKind = resource?.replace(/:/g, '~');\n  const kind = last(groupVersionKind.split('~'));\n  const [metaStr, queryParamsStr] = (qComponents ?? '').split(\n    K8S_RESOURCE_META_PARAMS_DIVIDER,\n  );\n  const meta = resolveKVParams(metaStr);\n  const queryParams = resolveKVParams(queryParamsStr);\n  return {\n    namespaced: NamespacedResourceKind.includes(kind),\n    labelSelector: queryParams.labelSelector,\n    isGlobal: !!meta.isGlobal,\n    groupVersionKind, // 现有的 apiversion，apiGroup 皆由环境配置，可以暂时不用\n    type: last(groupVersionKind.split('~')),\n    multiple,\n    validations,\n  };\n}\n\n// resolve a=b&c=d 格式数据\nexport function resolveKVParams(str: string) {\n  return (str || '')\n    .split('&')\n    .filter(i => !isEmpty(i))\n    .reduce((acc, curr) => {\n      const [k, v] = curr.split('=');\n      acc[k] = decodeURIComponent(v);\n      return acc;\n    }, {} as StringMap);\n}\n\nexport function getCapabilityDisabled(capabilities: SpecCapability[]): boolean {\n  return capabilities.includes(SpecCapability.disabled);\n}\n\nexport function getCapabilityValidations(\n  capabilities: SpecCapability[],\n): OperandFieldValidation {\n  const validations = capabilities?.filter(c =>\n    c.startsWith(SpecCapability.validation),\n  );\n  return validations.reduce((acc, descriptor) => {\n    const [, validation, param] =\n      (descriptor.match(REGEXP_VALIDATION_SUFFIX) as [\n        unknown,\n        Validations,\n        string,\n      ]) ?? [];\n    if (!validation) {\n      return acc;\n    }\n\n    if (validation === Validations.pattern) {\n      acc[validation] = param;\n    } else if (validation === Validations.required) {\n      acc[validation] = Boolean(param);\n    } else {\n      acc[validation] = +param;\n    }\n\n    return acc;\n  }, {} as OperandFieldValidation);\n}\n\nexport function getOneOfMap(field: OperandField) {\n  const map: Dictionary<string[]> = {};\n  const capabilities = field.capabilities.filter(c =>\n    c.startsWith(SpecCapability.oneOf),\n  );\n  capabilities.forEach(c => {\n    const str = c.split(SpecCapability.oneOf)[1];\n    // 这里 path 与后端约束直接支持 path@tag 模式\n    const [value, ...path] = str.split(':');\n    map[value] = [...path];\n  });\n  return map;\n}\n\nexport function fieldShouldReveal(field: OperandField) {\n  return (\n    !field.capabilities.includes(SpecCapability.hidden) &&\n    identity(getFieldType(field))\n  );\n}\n"]}

package/esm2022/lib/utils/constant.mjs

@@ -0,0 +1,22 @@
+import { escapeRegExp } from 'lodash-es';
+import { SpecCapability, Validations } from '../types';
+import * as ServiceModels from './service-model';
+export const MAX_DEPTH = 1;
+export const SCHEMA_PATH = ['properties', 'spec'];
+export const DESCRIPTOR_DEFINITION_KEY = 'x-descriptors';
+export const NamespacedResourceKind = Object.values(ServiceModels)
+    .filter(i => i.namespaced)
+    .map(i => i.kind);
+// Regex for SpecCapability.arrayFieldGroup and SpecCapability.fieldGroup
+const ARRAY_FIELD_GROUP_PATTERN = escapeRegExp(SpecCapability.arrayFieldGroup);
+const FIELD_GROUP_PATTERN = escapeRegExp(SpecCapability.fieldGroup);
+export const GROUP_PATTERN = new RegExp(`^(${FIELD_GROUP_PATTERN}|${ARRAY_FIELD_GROUP_PATTERN})(.*)$`);
+export const DEFAULT_VALUE_PATTERN = new RegExp(`^${escapeRegExp(SpecCapability.defaultValue)}(.*)$`);
+export const REGEXP_K8S_RESOURCE_CAPABILITY = escapeRegExp(SpecCapability.k8sResourcePrefix);
+export const REGEXP_CAPABILITY_VALIDATION = escapeRegExp(SpecCapability.validation);
+export const REGEXP_FIELD_DEPENDENCY_CAPABILITY = escapeRegExp(SpecCapability.fieldDependency);
+export const REGEXP_SELECT_CAPABILITY = escapeRegExp(SpecCapability.select);
+export const REGEXP_K8S_RESOURCE_SUFFIX = new RegExp(`^${REGEXP_K8S_RESOURCE_CAPABILITY}(?:core[:~]v1[:~])?([^?]*)(?:\\?\\+)?([^?]*)?(?:\\?\\=)?([^?]*)?$`);
+const SupportValidation = Object.values(Validations).join('|');
+export const REGEXP_VALIDATION_SUFFIX = new RegExp(`^${REGEXP_CAPABILITY_VALIDATION}(${SupportValidation})(?::(.+))?$`);
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/utils/directives.mjs

@@ -0,0 +1,19 @@
+import { Directive, Input, TemplateRef } from '@angular/core';
+import * as i0 from "@angular/core";
+export class CrdFormCustomDescriptionDirective {
+    constructor(templateRef) {
+        this.templateRef = templateRef;
+    }
+    static { this.ɵfac = function CrdFormCustomDescriptionDirective_Factory(t) { return new (t || CrdFormCustomDescriptionDirective)(i0.ɵɵdirectiveInject(i0.TemplateRef)); }; }
+    static { this.ɵdir = /*@__PURE__*/ i0.ɵɵdefineDirective({ type: CrdFormCustomDescriptionDirective, selectors: [["ng-template", "aclCrdFormCustomDescription", ""]], inputs: { aclCrdFormCustomDescription: "aclCrdFormCustomDescription" }, exportAs: ["aclCrdFormCustomDescription"] }); }
+}
+(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(CrdFormCustomDescriptionDirective, [{
+        type: Directive,
+        args: [{
+                selector: 'ng-template[aclCrdFormCustomDescription]',
+                exportAs: 'aclCrdFormCustomDescription',
+            }]
+    }], () => [{ type: i0.TemplateRef }], { aclCrdFormCustomDescription: [{
+            type: Input
+        }] }); })();
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGlyZWN0aXZlcy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uL2xpYnMvY3JkLWZvcm0vc3JjL2xpYi91dGlscy9kaXJlY3RpdmVzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxTQUFTLEVBQUUsS0FBSyxFQUFFLFdBQVcsRUFBRSxNQUFNLGVBQWUsQ0FBQzs7QUFNOUQsTUFBTSxPQUFPLGlDQUFpQztJQUk1QyxZQUFtQixXQUE2QjtRQUE3QixnQkFBVyxHQUFYLFdBQVcsQ0FBa0I7SUFBRyxDQUFDO2tHQUp6QyxpQ0FBaUM7b0VBQWpDLGlDQUFpQzs7aUZBQWpDLGlDQUFpQztjQUo3QyxTQUFTO2VBQUM7Z0JBQ1QsUUFBUSxFQUFFLDBDQUEwQztnQkFDcEQsUUFBUSxFQUFFLDZCQUE2QjthQUN4Qzs0Q0FHQywyQkFBMkI7a0JBRDFCLEtBQUsiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBEaXJlY3RpdmUsIElucHV0LCBUZW1wbGF0ZVJlZiB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuXG5ARGlyZWN0aXZlKHtcbiAgc2VsZWN0b3I6ICduZy10ZW1wbGF0ZVthY2xDcmRGb3JtQ3VzdG9tRGVzY3JpcHRpb25dJyxcbiAgZXhwb3J0QXM6ICdhY2xDcmRGb3JtQ3VzdG9tRGVzY3JpcHRpb24nLFxufSlcbmV4cG9ydCBjbGFzcyBDcmRGb3JtQ3VzdG9tRGVzY3JpcHRpb25EaXJlY3RpdmUge1xuICBASW5wdXQoKVxuICBhY2xDcmRGb3JtQ3VzdG9tRGVzY3JpcHRpb246IHN0cmluZztcblxuICBjb25zdHJ1Y3RvcihwdWJsaWMgdGVtcGxhdGVSZWY6IFRlbXBsYXRlUmVmPGFueT4pIHt9XG59XG4iXX0=

package/esm2022/lib/utils/helper.mjs

@@ -0,0 +1,201 @@
+import { cloneDeep, get, includes, map, reduce, some } from 'lodash-es';
+import { SpecCapability, Validations, } from '../types';
+export const isRequired = (field) => field?.required ||
+    Object.keys(field?.validations || {})?.includes(Validations.required);
+export const filterMapByKey = (map, predicate) => {
+    const m = new Map();
+    map.forEach((v, k) => {
+        if (predicate(k)) {
+            m.set(k, v);
+        }
+    });
+    return m;
+};
+export const getMatchArrayIndex = (arrPath) => {
+    // eslint-disable-next-line regexp/strict
+    const matched = arrPath.match(/(^.*)\[(\d+)]$/);
+    return +get(matched, '[2]', 0);
+};
+export const isGroupField = (field) => field.type === 'object';
+export const isArrayField = (field) => field.type === 'array';
+export const isRemoteField = (field) => field.capabilities.some(c => c.startsWith(SpecCapability.remote));
+export const isArrayFieldTable = (field) => isArrayField(field) &&
+    field.capabilities.some(c => c.startsWith('urn:alm:descriptor:widgets:common:arrayTable'));
+export const isCreatable = (field) => field.capabilities.some(c => c.startsWith(SpecCapability.creatable));
+export const isMultiple = (field) => field.capabilities.some(c => c.startsWith(SpecCapability.multiple));
+export const isAllowCreate = (field) => field.capabilities.some(c => c.startsWith(SpecCapability.allowCreate));
+export const isClearable = (field) => field.capabilities.some(c => c.startsWith(SpecCapability.clearable));
+export const isFolded = (field) => field.capabilities.some(c => c.startsWith(SpecCapability.folded));
+export const isEmptyArray = (field) => field.capabilities.some(c => c.startsWith(SpecCapability.emptyArray));
+export function hasDescriptor(field, prefix, suffix = null) {
+    return suffix
+        ? includes(field.capabilities, `${prefix}${suffix}`)
+        : some(field.capabilities, capability => capability.startsWith(prefix));
+}
+/*
+ * Matches a path that contains an array index. Use Sting.match against an OperandField 'path'
+ * property to determine if it contains an array index. It will parse the path into three parts,
+ * [match, pathBeforeIndex, index, pathAfterIndex]. For example:
+ *
+ *   const [match, pathBeforeIndex, index, pathAfterIndex] =
+ *     'path.before[0].path.after'.match(ARRAY_INDEX_PATTERN);
+ *
+ *   console.log(match);
+ *   > 'path.before[0].path.after'
+ *
+ *   console.log(pathBeforeIndex);
+ *   > 'path.before'
+ *
+ *   console.log(index)
+ *   > '0'
+ *
+ *   console.log(pathAfterIndex)
+ *   > 'path.after'
+ *
+ */
+// eslint-disable-next-line regexp/strict
+const ARRAY_INDEX_PATTERN = /^(.*)\[(\d+)]\.?(.*)$/;
+export function parseArrayPath(path) {
+    const [match, pathBeforeIndex, index, pathAfterIndex] = ARRAY_INDEX_PATTERN.exec(path) || [];
+    return match
+        ? { index: parseInt(index, 10), match, pathBeforeIndex, pathAfterIndex }
+        : { match };
+}
+export function getArrayGroupName(field) {
+    if (hasDescriptor(field, SpecCapability.arrayFieldGroup)) {
+        return field.capabilities
+            .find(capability => capability.startsWith(SpecCapability.arrayFieldGroup))
+            .slice(SpecCapability.arrayFieldGroup.length);
+    }
+    return '';
+}
+export function getGroupName(field) {
+    if (hasDescriptor(field, SpecCapability.fieldGroup)) {
+        return field.capabilities
+            .find(capability => capability.startsWith(SpecCapability.fieldGroup))
+            .slice(SpecCapability.fieldGroup.length);
+    }
+    return '';
+}
+/**
+ * 递归修复树形结构中 数组类型的索引
+ *
+ * @export
+ * @param {OperandField} field
+ * @param {string} fromPath
+ * @param {string} toPath
+ * @returns
+ *
+ */
+export const repairFieldChildPathByCorrectIndex = (field, fromPath, toPath) => {
+    const targetField = cloneDeep(field);
+    if (isGroupField(targetField)) {
+        targetField.fieldList = map(targetField.fieldList, f => ({
+            ...f,
+            path: f.path.replace(fromPath, toPath),
+        }));
+    }
+    else if (isArrayField(targetField)) {
+        targetField.fieldLists = reduce(targetField.fieldLists, (t, c) => [
+            ...t,
+            map(c, f => repairFieldChildPathByCorrectIndex(f, fromPath, toPath)),
+        ], []);
+    }
+    return {
+        ...targetField,
+        path: targetField.path.replace(fromPath, toPath),
+    };
+};
+export const getRelatedFields = (normalFields) => map(normalFields, field => {
+    if (getArrayGroupName(field)) {
+        const { pathBeforeIndex, index } = parseArrayPath(field.path);
+        return {
+            ...field,
+            parent: pathBeforeIndex,
+            inParentIndex: index,
+        };
+    }
+    if (getGroupName(field)) {
+        const groupNameFromDefinition = `spec.${getGroupName(field)}`;
+        const parent = field.path.slice(0, groupNameFromDefinition.length);
+        return {
+            ...field,
+            parent,
+        };
+    }
+    return field;
+});
+export const getTreeFields = (rootFields, basicFields) => {
+    if (basicFields.length > 0) {
+        return rootFields.reduce((acc, field) => {
+            field._dirty = true;
+            const children = basicFields.filter(f => f.parent === field.path);
+            children.forEach(c => (c._dirty = true));
+            if (isArrayField(field)) {
+                field.fieldLists = children
+                    .reduce((acc, child) => {
+                    acc[child.inParentIndex] = [
+                        ...(acc[child.inParentIndex] || []),
+                        child,
+                    ];
+                    return acc;
+                }, [])
+                    .map(m => getTreeFields(m, basicFields.filter(f => !f._dirty)));
+            }
+            else if (isGroupField(field)) {
+                field.fieldList = getTreeFields(children, basicFields.filter(f => !f._dirty));
+            }
+            return [...acc, field];
+        }, []);
+    }
+    return rootFields.map(f => {
+        f._dirty = true;
+        return f;
+    });
+};
+export const getMatchedCapabilityValue = (capabilities, descriptor) => capabilities
+    .find(capability => capability.startsWith(descriptor))
+    ?.slice(descriptor.length) || '';
+export function evalInContext(stringExpression, context) {
+    // replace eval, skip eslint & sonar safe check
+    function evil(fn) {
+        const Fn = Function;
+        return new Fn(`return ${fn}`);
+    }
+    try {
+        return evil(stringExpression).call(context);
+    }
+    catch {
+        console.error('expression is invalid:', stringExpression);
+        return stringExpression;
+    }
+}
+export function coerceBoolean(val) {
+    return val === 'true';
+}
+export function coerceNumber(val, fallbackValue = 0) {
+    return _isNumberValue(val) ? Number(val) : fallbackValue;
+}
+export function _isNumberValue(value) {
+    // parseFloat(value) handles most of the cases we're interested in (it treats null, empty string,
+    // and other non-number values as NaN, where Number just uses 0) but it considers the string
+    // '123hello' to be a valid number. Therefore we also check if Number(value) is NaN.
+    return (!isNaN(typeof value === 'string' && parseFloat(value)) &&
+        !isNaN(Number(value)));
+}
+export function getCustomDescription(customDescriptions, field) {
+    return customDescriptions?.find(des => `spec.${des.aclCrdFormCustomDescription}` === field.path);
+}
+export function getOperandPath(field) {
+    const idField = field?.capabilities.find(c => c.startsWith(SpecCapability.pathTag));
+    if (idField) {
+        return `${field.path}@${idField.slice(SpecCapability.pathTag.length)}`;
+    }
+    return field.path;
+}
+export function getPathFromTagPath(pathWithTag) {
+    return pathWithTag.split('@')[0];
+}
+// 获取path下所有的filed，例如spec.a 能匹配到 spec.a.a1 spec.a.a2
+export const getFieldsByPath = (path, fields) => fields.filter(field => getOperandPath(field).startsWith(path));
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"helper.js","sourceRoot":"","sources":["../../../../../../libs/crd-form/src/lib/utils/helper.ts"],"names":[],"mappings":"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","sourcesContent":["import { QueryList } from '@angular/core';\nimport { cloneDeep, get, includes, map, reduce, some } from 'lodash-es';\n\nimport {\n  OperandArrayFieldGroup,\n  OperandField,\n  OperandFieldGroup,\n  SpecCapability,\n  Validations,\n} from '../types';\n\nimport { CrdFormCustomDescriptionDirective } from './directives';\n\nexport const isRequired = (field: OperandField) =>\n  field?.required ||\n  Object.keys(field?.validations || {})?.includes(Validations.required);\n\nexport const filterMapByKey = <T>(\n  map: Map<string, T>,\n  predicate: (input: string) => boolean,\n) => {\n  const m = new Map();\n  map.forEach((v, k) => {\n    if (predicate(k)) {\n      m.set(k, v);\n    }\n  });\n  return m;\n};\n\nexport const getMatchArrayIndex = (arrPath: string) => {\n  // eslint-disable-next-line regexp/strict\n  const matched = arrPath.match(/(^.*)\\[(\\d+)]$/);\n  return +get(matched, '[2]', 0);\n};\n\nexport const isGroupField = (field: OperandField): field is OperandFieldGroup =>\n  field.type === 'object';\n\nexport const isArrayField = (\n  field: OperandField,\n): field is OperandArrayFieldGroup => field.type === 'array';\n\nexport const isRemoteField = (\n  field: OperandField,\n): field is OperandArrayFieldGroup =>\n  field.capabilities.some(c => c.startsWith(SpecCapability.remote));\n\nexport const isArrayFieldTable = (\n  field: OperandField,\n): field is OperandArrayFieldGroup =>\n  isArrayField(field) &&\n  field.capabilities.some(c =>\n    c.startsWith('urn:alm:descriptor:widgets:common:arrayTable'),\n  );\n\nexport const isCreatable = (field: OperandField) =>\n  field.capabilities.some(c => c.startsWith(SpecCapability.creatable));\n\nexport const isMultiple = (field: OperandField) =>\n  field.capabilities.some(c => c.startsWith(SpecCapability.multiple));\n\nexport const isAllowCreate = (field: OperandField) =>\n  field.capabilities.some(c => c.startsWith(SpecCapability.allowCreate));\n\nexport const isClearable = (field: OperandField) =>\n  field.capabilities.some(c => c.startsWith(SpecCapability.clearable));\n\nexport const isFolded = (field: OperandField) =>\n  field.capabilities.some(c => c.startsWith(SpecCapability.folded));\n\nexport const isEmptyArray = (field: OperandField) =>\n  field.capabilities.some(c => c.startsWith(SpecCapability.emptyArray));\n\nexport function hasDescriptor(\n  field: OperandField,\n  prefix: string,\n  suffix: string = null,\n): boolean {\n  return suffix\n    ? includes(field.capabilities, `${prefix}${suffix}`)\n    : some(field.capabilities, capability => capability.startsWith(prefix));\n}\n\n/*\n * Matches a path that contains an array index. Use Sting.match against an OperandField 'path'\n * property to determine if it contains an array index. It will parse the path into three parts,\n * [match, pathBeforeIndex, index, pathAfterIndex]. For example:\n *\n *   const [match, pathBeforeIndex, index, pathAfterIndex] =\n *     'path.before[0].path.after'.match(ARRAY_INDEX_PATTERN);\n *\n *   console.log(match);\n *   > 'path.before[0].path.after'\n *\n *   console.log(pathBeforeIndex);\n *   > 'path.before'\n *\n *   console.log(index)\n *   > '0'\n *\n *   console.log(pathAfterIndex)\n *   > 'path.after'\n *\n */\n// eslint-disable-next-line regexp/strict\nconst ARRAY_INDEX_PATTERN = /^(.*)\\[(\\d+)]\\.?(.*)$/;\n\nexport function parseArrayPath(path: string): {\n  index?: number;\n  match?: string;\n  pathBeforeIndex?: string;\n  pathAfterIndex?: string;\n} {\n  const [match, pathBeforeIndex, index, pathAfterIndex] =\n    ARRAY_INDEX_PATTERN.exec(path) || [];\n  return match\n    ? { index: parseInt(index, 10), match, pathBeforeIndex, pathAfterIndex }\n    : { match };\n}\n\nexport function getArrayGroupName(field: OperandField) {\n  if (hasDescriptor(field, SpecCapability.arrayFieldGroup)) {\n    return field.capabilities\n      .find(capability => capability.startsWith(SpecCapability.arrayFieldGroup))\n      .slice(SpecCapability.arrayFieldGroup.length);\n  }\n  return '';\n}\n\nexport function getGroupName(field: OperandField) {\n  if (hasDescriptor(field, SpecCapability.fieldGroup)) {\n    return field.capabilities\n      .find(capability => capability.startsWith(SpecCapability.fieldGroup))\n      .slice(SpecCapability.fieldGroup.length);\n  }\n\n  return '';\n}\n\n/**\n * 递归修复树形结构中 数组类型的索引\n *\n * @export\n * @param {OperandField} field\n * @param {string} fromPath\n * @param {string} toPath\n * @returns\n *\n */\nexport const repairFieldChildPathByCorrectIndex = (\n  field: OperandField,\n  fromPath: string,\n  toPath: string,\n) => {\n  const targetField = cloneDeep(field);\n  if (isGroupField(targetField)) {\n    targetField.fieldList = map(targetField.fieldList, f => ({\n      ...f,\n      path: f.path.replace(fromPath, toPath),\n    }));\n  } else if (isArrayField(targetField)) {\n    targetField.fieldLists = reduce(\n      targetField.fieldLists,\n      (t, c) => [\n        ...t,\n        map(c, f => repairFieldChildPathByCorrectIndex(f, fromPath, toPath)),\n      ],\n      [],\n    );\n  }\n  return {\n    ...targetField,\n    path: targetField.path.replace(fromPath, toPath),\n  };\n};\n\nexport const getRelatedFields = (normalFields: OperandField[]) =>\n  map(normalFields, field => {\n    if (getArrayGroupName(field)) {\n      const { pathBeforeIndex, index } = parseArrayPath(field.path);\n      return {\n        ...field,\n        parent: pathBeforeIndex,\n        inParentIndex: index,\n      };\n    }\n    if (getGroupName(field)) {\n      const groupNameFromDefinition = `spec.${getGroupName(field)}`;\n      const parent = field.path.slice(0, groupNameFromDefinition.length);\n      return {\n        ...field,\n        parent,\n      };\n    }\n    return field;\n  });\n\nexport const getTreeFields = (\n  rootFields: OperandField[],\n  basicFields: OperandField[],\n) => {\n  if (basicFields.length > 0) {\n    return rootFields.reduce((acc, field) => {\n      field._dirty = true;\n      const children = basicFields.filter(f => f.parent === field.path);\n      children.forEach(c => (c._dirty = true));\n      if (isArrayField(field)) {\n        field.fieldLists = children\n          .reduce((acc, child) => {\n            acc[child.inParentIndex] = [\n              ...(acc[child.inParentIndex] || []),\n              child,\n            ];\n            return acc;\n          }, [])\n          .map(m =>\n            getTreeFields(\n              m,\n              basicFields.filter(f => !f._dirty),\n            ),\n          );\n      } else if (isGroupField(field)) {\n        field.fieldList = getTreeFields(\n          children,\n          basicFields.filter(f => !f._dirty),\n        );\n      }\n      return [...acc, field];\n    }, []);\n  }\n  return rootFields.map(f => {\n    f._dirty = true;\n    return f;\n  });\n};\n\nexport const getMatchedCapabilityValue = (\n  capabilities: SpecCapability[],\n  descriptor: string,\n) =>\n  capabilities\n    .find(capability => capability.startsWith(descriptor))\n    ?.slice(descriptor.length) || '';\n\nexport function evalInContext(stringExpression: string, context: any) {\n  // replace eval, skip eslint & sonar safe check\n  function evil(fn: string) {\n    const Fn = Function;\n    return new Fn(`return ${fn}`);\n  }\n  try {\n    return evil(stringExpression).call(context);\n  } catch {\n    console.error('expression is invalid:', stringExpression);\n    return stringExpression;\n  }\n}\n\nexport function coerceBoolean(val: any): boolean {\n  return val === 'true';\n}\n\nexport function coerceNumber(val: any, fallbackValue = 0): number {\n  return _isNumberValue(val) ? Number(val) : fallbackValue;\n}\n\nexport function _isNumberValue(value: any): boolean {\n  // parseFloat(value) handles most of the cases we're interested in (it treats null, empty string,\n  // and other non-number values as NaN, where Number just uses 0) but it considers the string\n  // '123hello' to be a valid number. Therefore we also check if Number(value) is NaN.\n  return (\n    !isNaN(typeof value === 'string' && parseFloat(value)) &&\n    !isNaN(Number(value))\n  );\n}\n\nexport function getCustomDescription(\n  customDescriptions: QueryList<CrdFormCustomDescriptionDirective>,\n  field: OperandField,\n) {\n  return customDescriptions?.find(\n    des => `spec.${des.aclCrdFormCustomDescription}` === field.path,\n  );\n}\n\nexport function getOperandPath(field: OperandField) {\n  const idField = field?.capabilities.find(c =>\n    c.startsWith(SpecCapability.pathTag),\n  );\n  if (idField) {\n    return `${field.path}@${idField.slice(SpecCapability.pathTag.length)}`;\n  }\n  return field.path;\n}\n\nexport function getPathFromTagPath(pathWithTag: string) {\n  return pathWithTag.split('@')[0];\n}\n\n// 获取path下所有的filed，例如spec.a 能匹配到 spec.a.a1 spec.a.a2\nexport const getFieldsByPath = (path: string, fields: OperandField[]) =>\n  fields.filter(field => getOperandPath(field).startsWith(path));\n"]}