@oinone/kunlun-meta 6.2.0

package/src/plugin-loader/util/PluginLoadHelper.ts

@@ -0,0 +1,70 @@
+import { PluginLoader as InternalPluginLoader } from '../loader';
+import { CSSPlugin, JavascriptPlugin, PluginLoadDependencies, PluginLoadDependency, PluginLoadOption } from '../typing';
+
+let counter = 1;
+
+function isPluginLoadOption(plugin: unknown): plugin is PluginLoadOption {
+  return !!plugin;
+}
+
+export class PluginLoadHelper {
+  private constructor() {
+    // reject create object
+  }
+
+  public static async loadDependencies(dependencies: PluginLoadDependencies): Promise<void> {
+    let readyLoadDependencies: PluginLoadDependency[];
+    if (Array.isArray(dependencies)) {
+      readyLoadDependencies = dependencies;
+    } else {
+      readyLoadDependencies = [
+        {
+          type: 'umd',
+          dependencies
+        }
+      ];
+    }
+    await Promise.allSettled(
+      readyLoadDependencies.map((dependency) =>
+        InternalPluginLoader.loadDependencies(dependency.type, dependency.dependencies)
+      )
+    );
+  }
+
+  public static loadJavascript(plugins: JavascriptPlugin[]): Promise<void> {
+    return InternalPluginLoader.load(
+      plugins
+        .map((plugin): PluginLoadOption | undefined => {
+          if (typeof plugin === 'string') {
+            return {
+              id: `plugin-${counter++}`,
+              type: 'umd',
+              path: plugin
+            };
+          }
+          if (plugin.path) {
+            return {
+              id: `plugin-${counter++}`,
+              type: plugin.type || 'umd',
+              path: plugin.path
+            };
+          }
+          console.error('Invalid javascript plugin.', plugin);
+          return undefined;
+        })
+        .filter(isPluginLoadOption)
+    );
+  }
+
+  public static loadCSS(paths: CSSPlugin[]): Promise<void> {
+    return InternalPluginLoader.load(
+      paths.map((path): PluginLoadOption => {
+        return {
+          id: `plugin-css-${counter++}`,
+          type: 'css',
+          path
+        };
+      })
+    );
+  }
+}

package/src/plugin-loader/util/index.ts

@@ -0,0 +1 @@
+export * from './PluginLoadHelper';

package/src/util/element.ts

@@ -0,0 +1,154 @@
+import {
+  ActionElement,
+  ApiElement,
+  ClearElement,
+  ContextElement,
+  FieldElement,
+  PropElement,
+  RequestElement,
+  ResponseElement,
+  ViewElement
+} from '../element';
+
+import { IModelField, ElementType, IDslNode } from '../metadata';
+import { deepClone } from './helper';
+
+const createViewElement = (dslNode: IDslNode | undefined): ViewElement | null => {
+  if (!dslNode) {
+    return {} as ViewElement;
+  }
+  return !Array.isArray(dslNode) ? (deepClone(dslNode) as ViewElement) : null;
+};
+
+const createPropElements = (parentNode: IDslNode | undefined): PropElement[] => {
+  if (!parentNode || !parentNode.children) {
+    return [] as FieldElement[];
+  }
+  return parentNode.children
+    .filter((a) => a.tagName === ElementType.PROP)
+    .map((node) => {
+      return {
+        name: node.name,
+        textContent: node.textContent
+      } as FieldElement;
+    });
+};
+
+const createFieldElement = (fieldNode: IDslNode | undefined): FieldElement => {
+  if (!fieldNode) {
+    return {} as FieldElement;
+  }
+  return deepClone(fieldNode) as FieldElement;
+};
+
+const createFieldElements = (parentNode: IDslNode | undefined): FieldElement[] => {
+  if (!parentNode || !parentNode.children) {
+    return [] as FieldElement[];
+  }
+  return parentNode.children
+    .filter((a) => a.tagName === ElementType.FIELD)
+    .map((node) => {
+      return {
+        name: node.name,
+        textContent: node.textContent,
+        children: createFieldElements(node)
+      } as FieldElement;
+    });
+};
+
+/**
+ * 创建action元素
+ * @param actionNode
+ * @param parentDslNode actionNode所在的父节点
+ */
+const createActionElement = (actionNode: IDslNode, parentDslNode: IDslNode): ActionElement => {
+  if (!parentDslNode) {
+    return {} as ActionElement;
+  }
+  const actionEle = deepClone(actionNode) as ActionElement;
+  const apiNode =
+    (parentDslNode.children &&
+      parentDslNode.children.find((d) => d.tagName === ElementType.API && d.name === actionEle.submitApi)) ||
+    null;
+  if (apiNode) {
+    const apiEle = createApiElement(parentDslNode, actionEle.submitApi);
+    if (!apiEle) {
+      return {} as ActionElement;
+    }
+    actionEle.api = apiEle;
+  }
+  return actionEle;
+};
+
+const createApiElement = (parentDslNode: IDslNode, apiName: string, dslFields?: IModelField[]) => {
+  const apiNode =
+    (parentDslNode.children &&
+      parentDslNode.children.find((d) => d.tagName === ElementType.API && d.name === apiName)) ||
+    null;
+  if (!apiNode) {
+    console.warn(`api not fund: ${apiName}`, parentDslNode);
+    return null;
+  }
+  const apiElement = deepClone(apiNode) as ApiElement;
+  if (!apiElement.fun) {
+    console.warn(`api fun not fund: ${apiName}`, parentDslNode);
+  }
+  if (!apiElement.type) {
+    console.warn(`api type not fund: ${apiName}`, parentDslNode);
+  }
+  apiElement.context = {
+    props: createPropElements(apiNode!.children.find((d) => d.tagName === ElementType.CONTEXT))
+  } as ContextElement;
+  apiElement.request = {
+    fields: mergeFields(
+      createFieldElements(apiNode!.children.find((d) => d.tagName === ElementType.REQUEST)),
+      dslFields
+    )
+  } as RequestElement;
+  apiElement.response = {
+    fields: mergeFields(
+      createFieldElements(apiNode!.children.find((d) => d.tagName === ElementType.RESPONSE)),
+      dslFields
+    )
+  } as ResponseElement;
+  apiElement.clear = {
+    fields: createFieldElements(apiNode!.children.find((d) => d.tagName === ElementType.CLEAR))
+  } as ClearElement;
+  return apiElement;
+};
+
+function mergeFields(fieldElements: FieldElement[], dslFields?: IModelField[]) {
+  return fieldElements && fieldElements.length
+    ? fieldElements
+    : (dslFields || []).map((a) => modelField2fieldElement(a));
+}
+
+const fieldElement2ModelField = (fieldElement: FieldElement): IModelField => {
+  return {
+    name: fieldElement.data,
+    ttype: fieldElement.ttype,
+    references: fieldElement.references!,
+    relatedTtype: fieldElement.relatedTtype
+  } as IModelField;
+};
+
+const modelField2fieldElement = (modelField: IModelField): FieldElement => {
+  return {
+    data: modelField.name,
+    name: modelField.name,
+    ttype: modelField.ttype,
+    references: modelField.references,
+    relatedTtype: modelField.relatedTtype
+  } as FieldElement;
+};
+
+export {
+  createViewElement,
+  createApiElement,
+  createPropElements,
+  createFieldElements,
+  createActionElement,
+  createFieldElement,
+  fieldElement2ModelField,
+  modelField2fieldElement
+};

package/src/util/field.ts

@@ -0,0 +1,63 @@
+import { IModelField, ModelFieldType } from '../metadata/types';
+
+const isSimpleField = (field: IModelField): boolean => {
+  switch (field.ttype) {
+    case ModelFieldType.Boolean:
+    case ModelFieldType.Integer:
+    case ModelFieldType.Long:
+    case ModelFieldType.Float:
+    case ModelFieldType.Currency:
+    case ModelFieldType.String:
+    case ModelFieldType.Email:
+    case ModelFieldType.Phone:
+    case ModelFieldType.ID:
+    case ModelFieldType.Date:
+    case ModelFieldType.DateTime:
+    case ModelFieldType.Time:
+    case ModelFieldType.Year:
+    case ModelFieldType.Enum:
+    case ModelFieldType.MultiEnum:
+    case ModelFieldType.HTML:
+    case ModelFieldType.Map:
+    case ModelFieldType.Text: {
+      return true;
+    }
+    default: {
+      return false;
+    }
+  }
+};
+
+const isComplexTtype = (ttype: ModelFieldType): boolean => {
+  return [
+    ModelFieldType.OneToOne,
+    ModelFieldType.OneToMany,
+    ModelFieldType.ManyToOne,
+    ModelFieldType.ManyToMany
+  ].includes(ttype);
+};
+
+const isDateTtype = (ttype: ModelFieldType): boolean => {
+  return [ModelFieldType.Date, ModelFieldType.DateTime, ModelFieldType.Year, ModelFieldType.Time].includes(ttype);
+};
+const isNumberTtype = (ttype: ModelFieldType): boolean => {
+  return [
+    ModelFieldType.ID,
+    ModelFieldType.UID,
+    ModelFieldType.Integer,
+    ModelFieldType.Long,
+    ModelFieldType.Float,
+    ModelFieldType.Currency
+  ].includes(ttype);
+};
+
+const isStringTtype = (ttype: ModelFieldType) => {
+  return [
+    ModelFieldType.String,
+    ModelFieldType.Text,
+    ModelFieldType.HTML,
+    ModelFieldType.Phone,
+    ModelFieldType.Email
+  ].includes(ttype);
+};
+export { isSimpleField, isComplexTtype, isDateTtype, isNumberTtype, isStringTtype };

package/src/util/helper.ts

@@ -0,0 +1,6 @@
+function deepClone(obj) {
+  return obj == null ? obj : JSON.parse(JSON.stringify(obj));
+}
+export {
+  deepClone
+};

package/src/util/index.ts

@@ -0,0 +1,6 @@
+export * from './element';
+export * from './lang';
+export * from './field';
+export * from './helper';
+export * from './ke-common';
+export * from './validation-utils';

package/src/util/ke-common.ts

@@ -0,0 +1,25 @@
+/**
+ * 判断对象(特指除下划线外的属性的对象，所以取名为keObject)是否为空
+ * @param value
+ */
+const isEmptyKeObject = (value: any): boolean => {
+  if (value === false || value === 0) {
+    return false;
+  }
+  if (!value) {
+    return true;
+  }
+  if (value instanceof Object) {
+    if (Object.keys((value as Record<string, unknown>) || {}).length === 0) {
+      return true;
+    }
+    // 老版本的代码这样判断的，猜测是 _ 开头的属于前端定义有特殊意义的属性，所以不算是业务对象的属性
+    const keys = Object.keys((value as Record<string, unknown>) || {}).filter((name) => !name.startsWith('_'));
+    return keys.length === 0;
+  }
+  if (Array.isArray(value) && value.length === 0) {
+    return true;
+  }
+  return false;
+};
+export { isEmptyKeObject };

package/src/util/lang.ts

@@ -0,0 +1,8 @@
+/**
+ * Determine if the argument is shaped like a Promise
+ */
+export function isPromise<T = unknown>(obj: unknown): obj is Promise<T> {
+  // allow any Promise/A+ compliant thenable.
+  // It's up to the caller to ensure that obj.then conforms to the spec
+  return !!obj && typeof (obj as { then: unknown }).then === 'function';
+}

package/src/util/validation-utils.ts

@@ -0,0 +1,17 @@
+import { isEmptyKeObject } from './ke-common';
+
+const isValidateEmpty = (value: any): boolean => {
+  return isEmptyKeObject(value) || (Array.isArray(value) && value.length === 0);
+};
+
+const isEmptyValue = (value: any): value is null => {
+  return (
+    value === undefined ||
+    value === null ||
+    value === '' ||
+    (Array.isArray(value) && value.length === 0) ||
+    (typeof value === 'object' && Object.keys(value).length === 0)
+  );
+};
+
+export { isValidateEmpty, isEmptyValue };