cabloy 5.1.63 → 5.1.64

package/zova/pnpm-lock.yaml

@@ -231,6 +231,9 @@ importers:
       zova-module-basic-date:
         specifier: workspace:^
         version: link:src/suite/cabloy-basic/modules/basic-date
+      zova-module-basic-details:
+        specifier: workspace:^
+        version: link:src/suite/cabloy-basic/modules/basic-details
       zova-module-basic-form:
         specifier: workspace:^
         version: link:src/suite/cabloy-basic/modules/basic-form
@@ -1571,6 +1574,9 @@ importers:
       zova-module-basic-date:
         specifier: ^5.0.6
         version: link:modules/basic-date
+      zova-module-basic-details:
+        specifier: ^5.0.0
+        version: link:modules/basic-details
       zova-module-basic-form:
         specifier: ^5.0.7
         version: link:modules/basic-form
@@ -1663,6 +1669,15 @@ importers:
         specifier: ^6.1.3
         version: 6.1.3
 
+  src/suite/cabloy-basic/modules/basic-details:
+    devDependencies:
+      clean-package:
+        specifier: ^2.2.0
+        version: 2.2.0
+      rimraf:
+        specifier: ^6.1.3
+        version: 6.1.3
+
   src/suite/cabloy-basic/modules/basic-form:
     devDependencies:
       clean-package:

package/zova/src/suite/cabloy-basic/modules/basic-details/package.json

@@ -0,0 +1,52 @@
+{
+  "name": "zova-module-basic-details",
+  "version": "5.0.0",
+  "description": "",
+  "keywords": [
+    "Zova Module"
+  ],
+  "author": "",
+  "files": [
+    "mock",
+    "dist",
+    "src",
+    "icons",
+    "assets"
+  ],
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": [
+        "./src/index.ts",
+        "./dist/index.d.ts"
+      ],
+      "import": "./src/index.ts",
+      "default": "./dist/index.js"
+    },
+    "./*": "./*"
+  },
+  "scripts": {
+    "clean": "rimraf dist tsconfig.build.tsbuildinfo",
+    "tsc:publish": "npm run clean && node ../../../../../packages-cli/cli/src/bin/zova.ts :bin:buildModule --sourcemap && tsc -p tsconfig.build.json",
+    "prepublishOnly": "npm run tsc:publish",
+    "prepack": "clean-package",
+    "postpack": "clean-package restore && npm run clean"
+  },
+  "dependencies": {},
+  "devDependencies": {
+    "clean-package": "^2.2.0",
+    "rimraf": "^6.1.3"
+  },
+  "clean-package": {
+    "indent": 2,
+    "replace": {
+      "exports.\\..types": "./dist/index.d.ts"
+    },
+    "remove": [
+      "clean-package",
+      "devDependencies",
+      "exports.\\..import"
+    ]
+  },
+  "title": "basic-details"
+}

package/zova/src/suite/cabloy-basic/modules/basic-details/src/.metadata/component/actionCreate.ts

@@ -0,0 +1,31 @@
+import type { TypeControllerInnerProps } from 'zova';
+
+import { defineComponent } from 'vue';
+import { prepareComponentOptions, useController } from 'zova';
+
+import type { ControllerActionCreateProps } from '../../component/actionCreate/controller.jsx';
+
+import { ControllerActionCreate } from '../../component/actionCreate/controller.jsx';
+export type ZActionCreateProps = {
+  controllerRef?: (ref: ControllerActionCreate) => void;
+} & ControllerActionCreateProps;
+
+type ControllerInnerProps = TypeControllerInnerProps<
+  ControllerActionCreateProps,
+  keyof typeof ControllerActionCreate.$propsDefault
+>;
+declare module 'zova-module-basic-details' {
+  export interface ControllerActionCreate {
+    $props: ControllerInnerProps;
+  }
+}
+
+export const ZActionCreate = defineComponent((_props: ZActionCreateProps) => {
+  useController(ControllerActionCreate, undefined, undefined);
+  return () => {};
+}, prepareComponentOptions(ControllerActionCreate.$componentOptions));
+declare module 'zova-module-a-bean' {
+  export interface IVonaComponentRecord {
+    'basic-details:actionCreate': ControllerActionCreateProps;
+  }
+}

package/zova/src/suite/cabloy-basic/modules/basic-details/src/.metadata/component/blockDetails.ts

@@ -0,0 +1,34 @@
+import type { TypeControllerInnerProps } from 'zova';
+
+import { defineComponent } from 'vue';
+import { prepareComponentOptions, useController } from 'zova';
+
+import type { ControllerBlockDetailsProps } from '../../component/blockDetails/controller.jsx';
+
+import { ControllerBlockDetails } from '../../component/blockDetails/controller.jsx';
+export type ZBlockDetailsProps<TData extends {} = {}> = {
+  controllerRef?: (ref: ControllerBlockDetails<TData>) => void;
+} & ControllerBlockDetailsProps<TData>;
+
+type ControllerInnerProps<TData extends {} = {}> = TypeControllerInnerProps<
+  ControllerBlockDetailsProps<TData>,
+  keyof typeof ControllerBlockDetails.$propsDefault
+>;
+declare module 'zova-module-basic-details' {
+  export interface ControllerBlockDetails<TData extends {} = {}> {
+    $props: ControllerInnerProps<TData>;
+  }
+}
+
+export const ZBlockDetails = defineComponent(
+  <TData extends {} = {}>(_props: ZBlockDetailsProps<TData>) => {
+    useController(ControllerBlockDetails, undefined, undefined);
+    return () => {};
+  },
+  prepareComponentOptions(ControllerBlockDetails.$componentOptions),
+);
+declare module 'zova-module-a-bean' {
+  export interface IVonaComponentRecord {
+    'basic-details:blockDetails': ControllerBlockDetailsProps;
+  }
+}

package/zova/src/suite/cabloy-basic/modules/basic-details/src/.metadata/component/blockDetailsToolbarBulk.ts

@@ -0,0 +1,31 @@
+import type { TypeControllerInnerProps } from 'zova';
+
+import { defineComponent } from 'vue';
+import { prepareComponentOptions, useController } from 'zova';
+
+import type { ControllerBlockDetailsToolbarBulkProps } from '../../component/blockDetailsToolbarBulk/controller.jsx';
+
+import { ControllerBlockDetailsToolbarBulk } from '../../component/blockDetailsToolbarBulk/controller.jsx';
+export type ZBlockDetailsToolbarBulkProps = {
+  controllerRef?: (ref: ControllerBlockDetailsToolbarBulk) => void;
+} & ControllerBlockDetailsToolbarBulkProps;
+
+type ControllerInnerProps = TypeControllerInnerProps<
+  ControllerBlockDetailsToolbarBulkProps,
+  keyof typeof ControllerBlockDetailsToolbarBulk.$propsDefault
+>;
+declare module 'zova-module-basic-details' {
+  export interface ControllerBlockDetailsToolbarBulk {
+    $props: ControllerInnerProps;
+  }
+}
+
+export const ZBlockDetailsToolbarBulk = defineComponent((_props: ZBlockDetailsToolbarBulkProps) => {
+  useController(ControllerBlockDetailsToolbarBulk, undefined, undefined);
+  return () => {};
+}, prepareComponentOptions(ControllerBlockDetailsToolbarBulk.$componentOptions));
+declare module 'zova-module-a-bean' {
+  export interface IVonaComponentRecord {
+    'basic-details:blockDetailsToolbarBulk': ControllerBlockDetailsToolbarBulkProps;
+  }
+}

package/zova/src/suite/cabloy-basic/modules/basic-details/src/.metadata/component/formFieldDetails.ts

@@ -0,0 +1,31 @@
+import type { TypeControllerInnerProps } from 'zova';
+
+import { defineComponent } from 'vue';
+import { prepareComponentOptions, useController } from 'zova';
+
+import type { ControllerFormFieldDetailsProps } from '../../component/formFieldDetails/controller.jsx';
+
+import { ControllerFormFieldDetails } from '../../component/formFieldDetails/controller.jsx';
+export type ZFormFieldDetailsProps = {
+  controllerRef?: (ref: ControllerFormFieldDetails) => void;
+} & ControllerFormFieldDetailsProps;
+
+type ControllerInnerProps = TypeControllerInnerProps<
+  ControllerFormFieldDetailsProps,
+  keyof typeof ControllerFormFieldDetails.$propsDefault
+>;
+declare module 'zova-module-basic-details' {
+  export interface ControllerFormFieldDetails {
+    $props: ControllerInnerProps;
+  }
+}
+
+export const ZFormFieldDetails = defineComponent((_props: ZFormFieldDetailsProps) => {
+  useController(ControllerFormFieldDetails, undefined, undefined);
+  return () => {};
+}, prepareComponentOptions(ControllerFormFieldDetails.$componentOptions));
+declare module 'zova-module-a-bean' {
+  export interface IVonaComponentRecord {
+    'basic-details:formFieldDetails': ControllerFormFieldDetailsProps;
+  }
+}

package/zova/src/suite/cabloy-basic/modules/basic-details/src/.metadata/index.ts

@@ -0,0 +1,116 @@
+// eslint-disable
+/** controller: begin */
+export * from '../component/actionCreate/controller.jsx';
+export * from '../component/blockDetails/controller.jsx';
+export * from '../component/blockDetailsToolbarBulk/controller.jsx';
+export * from '../component/formFieldDetails/controller.jsx';
+
+import 'zova';
+declare module 'zova' {
+  
+  
+}
+declare module 'zova-module-basic-details' {
+  
+        export interface ControllerActionCreate {
+          /** @internal */
+          get scope(): ScopeModuleBasicDetails;
+        }
+
+        export interface ControllerBlockDetails {
+          /** @internal */
+          get scope(): ScopeModuleBasicDetails;
+        }
+
+        export interface ControllerBlockDetailsToolbarBulk {
+          /** @internal */
+          get scope(): ScopeModuleBasicDetails;
+        }
+
+        export interface ControllerFormFieldDetails {
+          /** @internal */
+          get scope(): ScopeModuleBasicDetails;
+        } 
+}
+/** controller: end */
+/** controller: begin */
+import { ControllerActionCreate } from '../component/actionCreate/controller.jsx';
+import { ControllerBlockDetails } from '../component/blockDetails/controller.jsx';
+import { ControllerBlockDetailsToolbarBulk } from '../component/blockDetailsToolbarBulk/controller.jsx';
+import { ControllerFormFieldDetails } from '../component/formFieldDetails/controller.jsx';
+import 'zova';
+declare module 'zova' {
+  export interface IBeanRecordLocal {
+    'basic-details.controller.actionCreate': ControllerActionCreate;
+'basic-details.controller.blockDetails': ControllerBlockDetails;
+'basic-details.controller.blockDetailsToolbarBulk': ControllerBlockDetailsToolbarBulk;
+'basic-details.controller.formFieldDetails': ControllerFormFieldDetails;
+  }
+}
+/** controller: end */
+
+/** components: begin */
+export * from './component/actionCreate.js';
+import { ZActionCreate } from './component/actionCreate.js';
+export * from './component/blockDetails.js';
+import { ZBlockDetails } from './component/blockDetails.js';
+export * from './component/blockDetailsToolbarBulk.js';
+import { ZBlockDetailsToolbarBulk } from './component/blockDetailsToolbarBulk.js';
+export * from './component/formFieldDetails.js';
+import { ZFormFieldDetails } from './component/formFieldDetails.js';
+export const components = {
+  'actionCreate': ZActionCreate,
+'blockDetails': ZBlockDetails,
+'blockDetailsToolbarBulk': ZBlockDetailsToolbarBulk,
+'formFieldDetails': ZFormFieldDetails,
+};
+import 'zova';
+declare module 'zova' {
+export interface IComponentRecord {
+  'basic-details:actionCreate': ControllerActionCreate;
+'basic-details:blockDetails': ControllerBlockDetails;
+'basic-details:blockDetailsToolbarBulk': ControllerBlockDetailsToolbarBulk;
+'basic-details:formFieldDetails': ControllerFormFieldDetails;
+}
+export interface IZovaComponentRecord {
+  'basic-details:actionCreate': typeof ZActionCreate;
+'basic-details:blockDetails': typeof ZBlockDetails;
+'basic-details:blockDetailsToolbarBulk': typeof ZBlockDetailsToolbarBulk;
+'basic-details:formFieldDetails': typeof ZFormFieldDetails;
+}
+}
+/** components: end */
+/** locale: begin */
+import { locales } from './locales.js';
+/** locale: end */
+/** scope: begin */
+import { BeanScopeBase, type BeanScopeUtil, TypeModuleLocales, TypeLocaleBase } from 'zova';
+import { Scope } from 'zova-module-a-bean';
+
+@Scope()
+export class ScopeModuleBasicDetails extends BeanScopeBase {}
+
+export interface ScopeModuleBasicDetails {
+  util: BeanScopeUtil;
+locale: TypeModuleLocales<(typeof locales)[TypeLocaleBase]>;
+}
+
+import 'zova';
+declare module 'zova' {
+  export interface IBeanScopeRecord {
+    'basic-details': ScopeModuleBasicDetails;
+  }
+  
+  
+
+  export interface IBeanScopeLocale {
+    'basic-details': (typeof locales)[TypeLocaleBase];
+  }
+
+  
+}
+
+export function locale<K extends keyof (typeof locales)[TypeLocaleBase]>(key: K): `basic-details::${K}` {
+  return `basic-details::${key}`;
+}  
+/** scope: end */

package/zova/src/suite/cabloy-basic/modules/basic-details/src/.metadata/locales.ts

@@ -0,0 +1,7 @@
+import locale_en_us from '../config/locale/en-us.js';
+import locale_zh_cn from '../config/locale/zh-cn.js';
+
+export const locales = {
+  'en-us': locale_en_us,
+  'zh-cn': locale_zh_cn,
+};

package/zova/src/suite/cabloy-basic/modules/basic-details/src/.metadata/this.ts

@@ -0,0 +1,2 @@
+export const __ThisModule__ = 'basic-details';
+export { ScopeModuleBasicDetails as ScopeModule } from './index.js';

package/zova/src/suite/cabloy-basic/modules/basic-details/src/component/actionCreate/controller.tsx

@@ -0,0 +1,42 @@
+import type { IComponentOptions } from 'zova';
+import type {
+  IJsxRenderContextDetails,
+  IResourceDetailsActionBulkOptionsBase,
+} from 'zova-module-a-openapi';
+
+import { BeanControllerBase, Use } from 'zova';
+import { Controller } from 'zova-module-a-bean';
+
+declare module 'zova-module-a-openapi' {
+  export interface IResourceDetailsActionBulkRecord {
+    'basic-details:actionCreate'?: ControllerActionCreateProps;
+  }
+}
+
+export interface ControllerActionCreateProps extends IResourceDetailsActionBulkOptionsBase {}
+
+@Controller()
+export class ControllerActionCreate extends BeanControllerBase {
+  static $propsDefault = {};
+  static $componentOptions: IComponentOptions = { inheritAttrs: false, deepExtendDefault: true };
+
+  @Use({ injectionScope: 'host' })
+  $$renderContext: IJsxRenderContextDetails;
+
+  protected async __init__() {}
+
+  protected render() {
+    return (
+      <button
+        class={this.$props.class}
+        type="button"
+        onClick={async () => {
+          console.log('create');
+          // await this.$performCommand('basic-commands:create', this.$props, this.$$renderContext);
+        }}
+      >
+        {this.scope.locale.Create()}
+      </button>
+    );
+  }
+}

package/zova/src/suite/cabloy-basic/modules/basic-details/src/component/blockDetails/controller.tsx

@@ -0,0 +1,114 @@
+import { celEnvBase } from '@cabloy/utils';
+import { VNode } from 'vue';
+import { BeanControllerBase, IComponentOptions } from 'zova';
+import { ZovaJsx } from 'zova-jsx';
+import { Controller } from 'zova-module-a-bean';
+import {
+  IDetailsScope,
+  IJsxRenderContextDetails,
+  IPermissionHintDetailsActionBulk,
+  IResourceBlockOptionsBase,
+  IResourceRenderBlockOptionsBlock,
+  ISchemaObjectExtensionField,
+  TypeFormScene,
+} from 'zova-module-a-openapi';
+import { BeanControllerTableBase } from 'zova-module-a-table';
+
+declare module 'zova-module-a-openapi' {
+  export interface IResourceBlockRecord {
+    'basic-details:blockDetails'?: ControllerBlockDetailsProps;
+  }
+}
+
+export interface ControllerBlockDetailsProps<
+  TData extends {} = {},
+> extends IResourceBlockOptionsBase {
+  blocks?: IResourceRenderBlockOptionsBlock[];
+  formScene?: TypeFormScene;
+  schemaRow?: ISchemaObjectExtensionField;
+  getDetailItems?: () => TData[] | undefined;
+  setDetailItems?: (detailItems: TData[]) => void;
+}
+
+@Controller()
+export class ControllerBlockDetails<TData extends {} = {}> extends BeanControllerBase {
+  static $propsDefault = {};
+  static $componentOptions: IComponentOptions = { inheritAttrs: false, deepExtendDefault: true };
+
+  tableRef: BeanControllerTableBase<TData>;
+
+  jsxZova: ZovaJsx;
+  jsxCelScope: IDetailsScope;
+  jsxRenderContext: IJsxRenderContextDetails<TData>;
+
+  protected async __init__() {
+    // jsx
+    this._prepareJsx();
+  }
+
+  get data() {
+    return this.$props.getDetailItems?.() ?? [];
+  }
+
+  get formScene() {
+    return this.$props.formScene!;
+  }
+
+  get schemaRow() {
+    return this.$props.schemaRow!;
+  }
+
+  public checkPermission(permissionHint?: IPermissionHintDetailsActionBulk): boolean {
+    const formScene = this.formScene;
+    const formSceneHint = permissionHint?.formScene;
+    if (!formSceneHint) return true;
+    if (Array.isArray(formSceneHint) && formSceneHint.includes(formScene!)) return true;
+    if (formSceneHint === formScene) return true;
+    return false;
+  }
+
+  private _prepareJsx() {
+    const jsxCelEnv = celEnvBase.clone();
+    this.jsxZova = this.bean._newBeanSimple(ZovaJsx, false, undefined, jsxCelEnv);
+    this.jsxCelScope = this._prepareJsxCelScope();
+    this.jsxRenderContext = {
+      app: this.app,
+      ctx: this.ctx,
+      $scene: 'details',
+      $host: this,
+      $celScope: this.jsxCelScope,
+      $jsx: this.jsxZova,
+      $$details: this,
+    };
+  }
+
+  private _prepareJsxCelScope(): IDetailsScope {
+    return {};
+  }
+
+  protected render() {
+    return <div class={this.$props.class}>{this._renderBlocks()}</div>;
+  }
+
+  private _renderBlocks() {
+    const blocks = this.$props.blocks;
+    if (!blocks || blocks.length === 0) return;
+    const domBlocks: VNode[] = [];
+    blocks.forEach((block, index) => {
+      const options = Object.assign({ key: index }, block.options);
+      const domBlock = this.jsxZova.render(
+        block.render!,
+        options,
+        this.jsxCelScope,
+        this.jsxRenderContext,
+      );
+      if (!domBlock) return;
+      if (Array.isArray(domBlock)) {
+        domBlocks.push(...domBlock);
+      } else {
+        domBlocks.push(domBlock);
+      }
+    });
+    return domBlocks;
+  }
+}

package/zova/src/suite/cabloy-basic/modules/basic-details/src/component/blockDetailsToolbarBulk/controller.tsx

@@ -0,0 +1,61 @@
+import type { IComponentOptions } from 'zova';
+import type {
+  IResourceBlockOptionsBase,
+  IJsxRenderContextDetails,
+  IResourceRenderDetailsActionBulkOptionsAction,
+} from 'zova-module-a-openapi';
+
+import { VNode } from 'vue';
+import { BeanControllerBase, Use } from 'zova';
+import { Controller } from 'zova-module-a-bean';
+
+declare module 'zova-module-a-openapi' {
+  export interface IResourceBlockRecord {
+    'basic-details:blockDetailsToolbarBulk'?: ControllerBlockDetailsToolbarBulkProps;
+  }
+}
+
+export interface ControllerBlockDetailsToolbarBulkProps extends IResourceBlockOptionsBase {
+  actions?: IResourceRenderDetailsActionBulkOptionsAction[];
+}
+
+@Controller()
+export class ControllerBlockDetailsToolbarBulk extends BeanControllerBase {
+  static $propsDefault = {};
+  static $componentOptions: IComponentOptions = { inheritAttrs: false, deepExtendDefault: true };
+
+  @Use({ injectionScope: 'host' })
+  $$renderContext: IJsxRenderContextDetails;
+
+  protected async __init__() {}
+
+  protected render() {
+    const domActions = this._renderActions();
+    if (!domActions || domActions.length === 0) return;
+    return (
+      <div class={this.$props.class}>
+        <div class="join">{domActions}</div>
+      </div>
+    );
+  }
+
+  private _renderActions() {
+    const { $jsx, $celScope, $$details } = this.$$renderContext;
+    const actions = this.$props.actions;
+    if (!actions || actions.length === 0) return;
+    const domActions: VNode[] = [];
+    actions.forEach((action, index) => {
+      const permissionHint = action.options?.permission;
+      if (!$$details.checkPermission(permissionHint)) return;
+      const options = Object.assign({ key: index }, action.options);
+      const domAction = $jsx.render(action.render!, options, $celScope, this.$$renderContext);
+      if (!domAction) return;
+      if (Array.isArray(domAction)) {
+        domActions.push(...domAction);
+      } else {
+        domActions.push(domAction);
+      }
+    });
+    return domActions;
+  }
+}

package/zova/src/suite/cabloy-basic/modules/basic-details/src/component/formFieldDetails/controller.tsx

@@ -0,0 +1,105 @@
+import type { IComponentOptions } from 'zova';
+import type {
+  ControllerFormField,
+  IFormFieldComponentOptions,
+  IFormFieldRenderContext,
+} from 'zova-module-a-form';
+import type {
+  IResourceFormFieldOptionsBase,
+  ISchemaObjectExtensionField,
+  TypeFormScene,
+} from 'zova-module-a-openapi';
+
+import { VNode } from 'vue';
+import { BeanControllerBase, deepExtend } from 'zova';
+import { ZovaJsx } from 'zova-jsx';
+import { Controller } from 'zova-module-a-bean';
+import { ZFormField } from 'zova-module-a-form';
+
+declare module 'zova-module-a-openapi' {
+  export interface IResourceFormFieldRecord {
+    'basic-details:formFieldDetails'?: IResourceFormFieldDetailsOptions;
+  }
+}
+
+export interface IResourceFormFieldDetailsOptions extends IResourceFormFieldOptionsBase {}
+
+export interface ControllerFormFieldDetailsProps extends IFormFieldComponentOptions {
+  options?: IResourceFormFieldDetailsOptions;
+}
+
+@Controller()
+export class ControllerFormFieldDetails extends BeanControllerBase {
+  static $propsDefault = {};
+  static $componentOptions: IComponentOptions = { inheritAttrs: false, deepExtendDefault: true };
+
+  jsxZova: ZovaJsx;
+
+  protected async __init__() {
+    // jsx
+    this._prepareJsx();
+  }
+
+  private _prepareJsx() {
+    this.jsxZova = this.bean._newBeanSimple(ZovaJsx, false);
+  }
+
+  protected render() {
+    return (
+      <ZFormField
+        {...this.$props}
+        slotDefault={(formFieldRenderContext, $$formField) => {
+          return this._renderBlocks(formFieldRenderContext, $$formField) ?? <></>;
+        }}
+      ></ZFormField>
+    );
+  }
+
+  private _renderBlocks(
+    formFieldRenderContext: IFormFieldRenderContext,
+    $$formField: ControllerFormField,
+  ) {
+    const { propsBucket } = formFieldRenderContext;
+    // schema
+    const schemaName = $$formField.property?.items?.$ref;
+    if (!schemaName) {
+      return <div>Should specify the detail schema</div>;
+    }
+    const schemaRow: ISchemaObjectExtensionField | undefined = this.$sdk.getSchema(
+      schemaName!,
+    ).data;
+    if (!schemaRow) return;
+    // formScene
+    const formScene: TypeFormScene = propsBucket.readonly
+      ? 'view'
+      : $$formField.formMeta!.formScene!;
+    // blocks
+    const blocks = schemaRow?.rest?.blocks;
+    if (!blocks || blocks.length === 0) return;
+    const domBlocks: VNode[] = [];
+    blocks.forEach((block, index) => {
+      const options = deepExtend(
+        { key: index },
+        {
+          formScene,
+          schemaRow,
+          getDetailItems: () => {
+            return propsBucket.value;
+          },
+          setDetailItems: (detailItems: any[]) => {
+            $$formField.setValue(detailItems);
+          },
+        },
+        block.options,
+      );
+      const domBlock = this.jsxZova.render(block.render!, options);
+      if (!domBlock) return;
+      if (Array.isArray(domBlock)) {
+        domBlocks.push(...domBlock);
+      } else {
+        domBlocks.push(domBlock);
+      }
+    });
+    return <div>{domBlocks}</div>;
+  }
+}

package/zova/src/suite/cabloy-basic/modules/basic-details/src/config/locale/en-us.ts

@@ -0,0 +1,3 @@
+export default {
+  Create: 'Create',
+};

package/zova/src/suite/cabloy-basic/modules/basic-details/src/config/locale/zh-cn.ts

@@ -0,0 +1,3 @@
+export default {
+  Create: '创建',
+};

package/zova/src/suite/cabloy-basic/modules/basic-details/src/index.ts

@@ -0,0 +1,3 @@
+export * from './.metadata/locales.js';
+export * from './types/index.js';
+export * from './.metadata/index.js';