cabloy 5.1.209 → 5.1.211

package/zova/src/suite/a-training/modules/training-student/src/api/trainingStudent.ts

@@ -82,6 +82,7 @@ export type ApiApiTrainingStudentdeleteForceResponseBody =
 
 @Api()
 export class ApiTrainingStudent extends BeanApiBase {
+  /** List Students */
   select(
     options?: {
       query?: ApiApiTrainingStudentselectRequestQuery;
@@ -93,6 +94,7 @@ export class ApiTrainingStudent extends BeanApiBase {
     );
   }
 
+  /** Create Student */
   create(body: ApiApiTrainingStudentcreateRequestBody, options?: IApiActionOptions) {
     return this.$fetch.post<any, ApiApiTrainingStudentcreateResponseBody>(
       ApiApiTrainingStudentcreatePath,
@@ -101,6 +103,7 @@ export class ApiTrainingStudent extends BeanApiBase {
     );
   }
 
+  /** View Student */
   view(
     options: {
       params: ApiApiTrainingStudentviewRequestParams;
@@ -112,6 +115,7 @@ export class ApiTrainingStudent extends BeanApiBase {
     );
   }
 
+  /** Delete Student */
   delete(
     options: {
       params: ApiApiTrainingStudentdeleteRequestParams;
@@ -123,6 +127,7 @@ export class ApiTrainingStudent extends BeanApiBase {
     );
   }
 
+  /** Update Student */
   update(
     body: ApiApiTrainingStudentupdateRequestBody,
     options: {
@@ -136,6 +141,7 @@ export class ApiTrainingStudent extends BeanApiBase {
     );
   }
 
+  /** View Student Summary */
   summary(
     options: {
       params: ApiApiTrainingStudentsummaryRequestParams;
@@ -147,7 +153,7 @@ export class ApiTrainingStudent extends BeanApiBase {
     );
   }
 
-  /** Bulk Delete */
+  /** Bulk Delete Students */
   deleteBulk(body: ApiApiTrainingStudentdeleteBulkRequestBody, options?: IApiActionOptions) {
     return this.$fetch.post<any, ApiApiTrainingStudentdeleteBulkResponseBody>(
       ApiApiTrainingStudentdeleteBulkPath,
@@ -156,6 +162,7 @@ export class ApiTrainingStudent extends BeanApiBase {
     );
   }
 
+  /** Permanently Delete Student */
   deleteForce(
     options: {
       params: ApiApiTrainingStudentdeleteForceRequestParams;

package/zova/src/suite/cabloy-basic/modules/basic-input/src/component/formFieldInput/controller.tsx

@@ -5,7 +5,7 @@ import type { IResourceFormFieldOptionsBase } from 'zova-module-a-openapi';
 import { classes } from 'typestyle';
 import { BeanControllerBase } from 'zova';
 import { Controller } from 'zova-module-a-bean';
-import { ZFormField } from 'zova-module-a-form';
+import { constFieldBindingSlot, ZFormField } from 'zova-module-a-form';
 
 declare module 'zova-module-a-openapi' {
   export interface IResourceFormFieldRecord {
@@ -37,6 +37,7 @@ export class ControllerFormFieldInput extends BeanControllerBase {
     return (
       <ZFormField
         {...this.$props}
+        {...{ [constFieldBindingSlot]: true }}
         slotDefault={({ propsBucket, props }, $$formField) => {
           const className = !propsBucket.needHandleBorder
             ? props.class

package/zova/src/suite-vendor/a-zova/modules/a-form/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zova-module-a-form",
-  "version": "5.1.52",
+  "version": "5.1.54",
   "gitHead": "09d901d17140a80ee0764211b441cda72fd94663",
   "description": "",
   "keywords": [

package/zova/src/suite-vendor/a-zova/modules/a-form/src/component/formField/controller.tsx

@@ -12,6 +12,7 @@ import type { ControllerForm } from '../form/controller.jsx';
 import { schemaRefreshFingerprint } from '../../lib/schemaRefresh.js';
 import { TypeFormField } from '../../types/form.js';
 import {
+  constFieldBindingSlot,
   constFieldProps,
   IFormFieldComponentOptions,
   IFormFieldOptions,
@@ -105,6 +106,7 @@ export class ControllerFormField<TParentData extends {} = {}> extends BeanContro
       props.behaviors,
       !!props.onEffect,
       !!props.slotDefault,
+      props[constFieldBindingSlot] === true,
     ]);
   }
 
@@ -118,12 +120,9 @@ export class ControllerFormField<TParentData extends {} = {}> extends BeanContro
       return;
     }
     const props = this.$props;
-    // Basic Input owns its binding slot; direct custom slots remain opaque.
+    // Only explicitly renderer-owned binding slots qualify; custom slots remain opaque.
     const inputBindingSlot =
-      props[constFieldProps] === true &&
-      (props.render
-        ? this.$$form.getRenderProvider(props.render)
-        : this.formProvider.components?.Input) === 'basic-input:formFieldInput';
+      props[constFieldProps] === true && props[constFieldBindingSlot] === true;
     const eligible =
       !props.sys &&
       !props.behaviors &&

package/zova/src/suite-vendor/a-zova/modules/a-form/src/lib/schemaRefresh.ts

@@ -238,18 +238,16 @@ function opaqueBehavior(value: unknown): boolean {
   );
 }
 
+const pageEntryBlockOptions = ['blocks', 'resource', 'id', 'formScene', 'pageTitleKey', 'draft'];
 const blockOptions: Record<string, string[]> = {
-  'basic-pageentry:blockPageEntry': [
-    'blocks',
-    'resource',
-    'id',
-    'formScene',
-    'pageTitleKey',
-    'draft',
-  ],
+  'basic-pageentry:blockPageEntry': pageEntryBlockOptions,
+  'start-pageentry:blockPageEntry': pageEntryBlockOptions,
   'basic-pageentry:blockForm': ['blocks'],
+  'start-pageentry:blockForm': ['blocks'],
   'basic-form:blockFormLayout': ['formLayout'],
+  'start-form:blockFormLayout': ['formLayout'],
   'basic-pageentry:blockToolbarRow': ['actions'],
+  'start-pageentry:blockToolbarRow': ['actions'],
 };
 
 function safeLayoutNode(value: unknown): boolean {
@@ -317,7 +315,7 @@ function safeBlocks(value: unknown): boolean {
   );
 }
 
-// Only Basic's declared layout grammar owns these title strings. Rest data/options,
+// Only Basic's and Start's declared layout grammar owns these title strings. Rest data/options,
 // action metadata, descriptions, field names, and unknown structures stay strict.
 function normalizeLayoutNode(value: unknown): unknown {
   if (!isRecord(value)) return value;
@@ -334,7 +332,12 @@ function normalizeBlocks(value: unknown): unknown {
     if (!isRecord(block) || !isRecord(block.options)) return block;
     const options = { ...block.options };
     if (Object.hasOwn(options, 'blocks')) options.blocks = normalizeBlocks(options.blocks);
-    if (block.render === 'basic-form:blockFormLayout' && safeLayout(options.formLayout)) {
+    if (
+      ['basic-form:blockFormLayout', 'start-form:blockFormLayout'].includes(
+        block.render as string,
+      ) &&
+      safeLayout(options.formLayout)
+    ) {
       const layout = options.formLayout as Record<string, unknown>;
       options.formLayout = { children: (layout.children as unknown[]).map(normalizeLayoutNode) };
     }
@@ -425,7 +428,13 @@ export function createSchemaRefreshContract(
       const form = isRecord(rest.form) ? rest.form : undefined;
       const render = rest.render ?? form?.render;
       const renderType = isRecord(render) ? render.type : render;
-      if (renderType !== 'basic-details:formFieldDetails') continue;
+      if (
+        !['basic-details:formFieldDetails', 'start-details:formFieldDetails'].includes(
+          String(renderType),
+        )
+      ) {
+        continue;
+      }
       for (const name of [
         property.key,
         property.schemaKey,
@@ -434,7 +443,7 @@ export function createSchemaRefreshContract(
         if (typeof name === 'string') detailNames.add(name);
       }
     }
-    // Basic Details resolves its row schema through the exact hidden `_name` auxiliary.
+    // Basic and Start Details resolve row schemas through the exact hidden `_name` auxiliary.
     // It belongs to that nested form, not to an unrelated parent field's behavior scope.
     const auxiliaryDetails = new Set<string>();
     for (const property of effective) {

package/zova/src/suite-vendor/a-zova/modules/a-form/src/types/formField.ts

@@ -28,6 +28,8 @@ export type HTMLInputElementType =
   | 'tel'
   | 'email';
 export const constFieldProps = '$$FieldProps';
+// Internal: the renderer supplies its own form-value binding slot.
+export const constFieldBindingSlot = '$$FieldBindingSlot';
 
 export interface IFormFieldScope<TParentData extends {} = {}> {
   name: string;

package/zova/src/suite-vendor/a-zova/modules/a-form/test/lib/schemaRefreshLifecycle.test.ts

@@ -22,7 +22,12 @@ function deferred<T = void>() {
 
 // Like basic-pageentry's draftModel harness, execute the current source rather than a
 // copied refresh algorithm. TSX requires transpileModule instead of native stripping.
-function evaluateClass(path: string, name: string, bindings: Record<string, unknown>) {
+function evaluateClass(
+  path: string,
+  name: string,
+  bindings: Record<string, unknown>,
+  jsx = ts.JsxEmit.Preserve,
+) {
   const source = readFileSync(new URL(path, import.meta.url), 'utf8')
     .replace(/^import[\s\S]*?;\n/gm, '')
     .replace(/^\s*@(Controller|UseScope|Use)\([^\n]*\)\s*\n/gm, '');
@@ -32,7 +37,8 @@ function evaluateClass(path: string, name: string, bindings: Record<string, unkn
     compilerOptions: {
       target: ts.ScriptTarget.ES2022,
       module: ts.ModuleKind.ESNext,
-      jsx: ts.JsxEmit.Preserve,
+      jsx,
+      jsxFactory: 'createElement',
     },
   });
   assert.deepEqual(
@@ -85,7 +91,14 @@ class ControllerBase {
   }
 }
 
-const constFieldProps = Symbol('constFieldProps');
+const fieldTypes = ts.transpileModule(
+  readFileSync(new URL('../../src/types/formField.ts', import.meta.url), 'utf8'),
+  { compilerOptions: { module: ts.ModuleKind.CommonJS } },
+).outputText;
+const { constFieldProps, constFieldBindingSlot } = new Function(
+  'exports',
+  `${fieldTypes}\nreturn exports;`,
+)({});
 const commonBindings = {
   markRaw: (value: unknown) => value,
   useSelector: (store: any, selector: (state: any) => any) => ({
@@ -95,8 +108,32 @@ const commonBindings = {
   isNil: (value: unknown) => value === undefined || value === null,
   schemaRefreshFingerprint,
   constFieldProps,
+  constFieldBindingSlot,
 };
 
+const ZFormField = {};
+const ControllerFormFieldInput = evaluateClass(
+  '../../../../../../suite/cabloy-basic/modules/basic-input/src/component/formFieldInput/controller.tsx',
+  'ControllerFormFieldInput',
+  {
+    BeanControllerBase: ControllerBase,
+    constFieldBindingSlot,
+    ZFormField,
+    classes: (...values: unknown[]) => values.filter(Boolean).join(' '),
+    createElement: (type: unknown, props: any) => ({ type, props }),
+  },
+  ts.JsxEmit.React,
+);
+
+function inputBindingProps(props: any = {}) {
+  const input = new ControllerFormFieldInput();
+  input.$props = props;
+  const rendered = input.render();
+  assert.equal(rendered.type, ZFormField);
+  assert.equal(rendered.props[constFieldBindingSlot], true);
+  return rendered.props;
+}
+
 const ControllerForm = evaluateClass('../../src/component/form/controller.tsx', 'ControllerForm', {
   ...commonBindings,
   BeanControllerFormBase: ControllerBase,
@@ -387,6 +424,118 @@ test(
   },
 );
 
+test(
+  'Start edit layout locale refresh preserves recovered input while localized custom options reset',
+  { concurrency: false },
+  async () => {
+    const nestedEffect = () => {};
+    const studentSchema = (locale: string) => {
+      const title = locale === 'en-us' ? 'Training Records' : '培训记录';
+      const result: any = schema(
+        locale,
+        {},
+        {
+          rest: {
+            blocks: [
+              {
+                render: 'start-pageentry:blockPageEntry',
+                options: {
+                  blocks: [
+                    {
+                      render: 'start-pageentry:blockForm',
+                      options: {
+                        blocks: [
+                          {
+                            render: 'start-form:blockFormLayout',
+                            options: {
+                              formLayout: {
+                                children: [
+                                  {
+                                    type: 'tabs',
+                                    children: [
+                                      {
+                                        type: 'tab',
+                                        title,
+                                        children: [{ type: 'field', name: 'name' }],
+                                      },
+                                    ],
+                                  },
+                                ],
+                              },
+                            },
+                          },
+                        ],
+                      },
+                    },
+                    {
+                      render: 'start-pageentry:blockToolbarRow',
+                      options: {
+                        actions: [
+                          {
+                            render: 'start-form:actionSubmit',
+                            options: { permission: { actionInherit: 'update' } },
+                          },
+                        ],
+                      },
+                    },
+                  ],
+                },
+              },
+            ],
+          },
+        },
+      );
+      result.properties.level = {
+        type: 'number',
+        rest: {
+          form: {
+            render: 'training-student:formFieldLevel',
+            options: { items: [{ value: 1, title }] },
+          },
+        },
+      };
+      result.properties.trainingRecords = {
+        type: 'array',
+        rest: { form: { render: 'start-details:formFieldDetails' } },
+        items: {
+          type: 'object',
+          properties: {
+            subject: { type: 'string', rest: { onEffect: nestedEffect } },
+          },
+        },
+      };
+      return result;
+    };
+    await withRuntime(
+      { data: { name: 'baseline', level: 1 }, schema: studentSchema('en-us') },
+      async runtime => {
+        const name = await initializedField(runtime, inputBindingProps());
+        const level = await initializedField(runtime, {
+          name: 'level',
+          slotDefault: () => 'custom level options',
+        });
+        runtime.form.reset(
+          { name: 'recovered unsaved name', level: 2 },
+          { keepDefaultValues: true },
+        );
+        // Establish the post-recovery epoch before switching locales, like mounted fields do.
+        name.refresh();
+        level.refresh();
+        for (const locale of ['zh-cn', 'en-us']) {
+          runtime.form.form.setFieldValue('level', 2, { dontValidate: true });
+          runtime.events.length = 0;
+          runtime.select(locale, studentSchema(locale));
+          name.refresh();
+          level.refresh();
+          assert.equal(runtime.form.form.getFieldValue('name'), 'recovered unsaved name');
+          assert.equal(runtime.form.form.getFieldValue('level'), 1);
+          assert.deepEqual(runtime.changed, []);
+        }
+      },
+    );
+  },
+);
+
 test(
   'locale replay preserves exact raw empty and falsy values',
   { concurrency: false },
@@ -732,6 +881,7 @@ test(
       const before: unknown[] = [];
       const after: unknown[] = [];
       const owner = await initializedField(runtime, {
+        [constFieldBindingSlot]: true,
         slotDefault: () => 'initial slot',
         onFieldStateReady: (field: any) => before.push(field.form.getFieldValue(field.name)),
       });
@@ -755,31 +905,30 @@ test(
 );
 
 test(
-  'canonical Basic input binding slots preserve live names across locale refresh',
+  'explicit renderer-owned binding slots preserve live names independently of component selectors',
   { concurrency: false },
   async () => {
-    for (const render of [
-      undefined,
-      'Input',
-      'basic-input:formFieldInput',
-      { $$typeof: 'zova-jsx:component', type: 'basic-input:formFieldInput' },
-    ]) {
-      await withRuntime({}, async runtime => {
-        runtime.form.$$scopeOpenapi.config.formProvider = {
-          components: { Input: 'basic-input:formFieldInput' },
-        };
-        const owner = await initializedField(runtime, {
-          render,
-          slotDefault: () => 'binding slot',
+    for (const selector of ['basic-input:formFieldInput', 'start-input:formFieldInput']) {
+      for (const render of [
+        undefined,
+        'Input',
+        selector,
+        { $$typeof: 'zova-jsx:component', type: selector },
+      ]) {
+        await withRuntime({}, async runtime => {
+          runtime.form.$$scopeOpenapi.config.formProvider = {
+            components: { Input: selector },
+          };
+          const owner = await initializedField(runtime, inputBindingProps({ render }));
+          dirty(runtime, 'typed name');
+          runtime.select('zh-cn');
+          owner.refresh();
+          assert.deepEqual(lifecycle(runtime.events), ['update', 'reset', 'validate', 'ready']);
+          assert.equal(lastEvent(runtime.events).value, 'typed name');
+          assertResetMeta(lastEvent(runtime.events).meta);
+          assert.deepEqual(runtime.changed, []);
         });
-        dirty(runtime, 'typed name');
-        runtime.select('zh-cn');
-        owner.refresh();
-        assert.deepEqual(lifecycle(runtime.events), ['update', 'reset', 'validate', 'ready']);
-        assert.equal(lastEvent(runtime.events).value, 'typed name');
-        assertResetMeta(lastEvent(runtime.events).meta);
-        assert.deepEqual(runtime.changed, []);
-      });
+      }
     }
   },
 );
@@ -789,9 +938,13 @@ test(
   { concurrency: false },
   async () => {
     for (const props of [
-      { [constFieldProps]: false, render: 'basic-input:formFieldInput' },
+      inputBindingProps({ [constFieldProps]: false, render: 'basic-input:formFieldInput' }),
+      { render: 'basic-input:formFieldInput' },
       { render: 'custom:formFieldInput' },
       { render: 'Input' },
+      {},
+      { [constFieldBindingSlot]: false },
+      { [constFieldBindingSlot]: 'true' },
     ]) {
       await withRuntime({}, async runtime => {
         runtime.form.$$scopeOpenapi.config.formProvider = {
@@ -812,6 +965,69 @@ test(
   },
 );
 
+test('the input wrapper owns its marker and value/blur binding slot', () => {
+  const externalSlot = () => 'external slot';
+  const props = inputBindingProps({
+    name: 'name',
+    [constFieldBindingSlot]: false,
+    slotDefault: externalSlot,
+  });
+  assert.equal(props.name, 'name');
+  assert.notEqual(props.slotDefault, externalSlot);
+  const writes: unknown[] = [];
+  let blurred = false;
+  const input = props.slotDefault(
+    { propsBucket: { value: 'current', disableNotifyChanged: true }, props: {} },
+    {
+      setValue: (...args: unknown[]) => writes.push(args),
+      handleBlur: () => {
+        blurred = true;
+      },
+    },
+  );
+  assert.equal(input.type, 'input');
+  assert.equal(input.props.value, 'current');
+  input.props.onInput({ target: { value: 'edited' } });
+  input.props.onBlur();
+  assert.deepEqual(writes, [['edited', true]]);
+  assert.equal(blurred, true);
+});
+
+test(
+  'a missing Input provider does not authorize an unmarked slot',
+  { concurrency: false },
+  async () => {
+    await withRuntime({}, async runtime => {
+      const owner = await initializedField(runtime, { slotDefault: () => 'custom slot' });
+      dirty(runtime, 'typed name');
+      runtime.select('zh-cn');
+      owner.refresh();
+      assert.deepEqual(lifecycle(runtime.events), ['update', 'reset', 'ready']);
+      assert.equal(lastEvent(runtime.events).value, 'baseline');
+    });
+  },
+);
+
+test(
+  'binding-slot ownership changes invalidate the prior refresh configuration',
+  { concurrency: false },
+  async () => {
+    for (const initiallyOwned of [false, true]) {
+      await withRuntime({}, async runtime => {
+        const owner = await initializedField(runtime, {
+          [constFieldBindingSlot]: initiallyOwned,
+          slotDefault: () => 'slot',
+        });
+        dirty(runtime, 'typed name');
+        owner.field.$props[constFieldBindingSlot] = !initiallyOwned;
+        owner.refresh();
+        assert.deepEqual(lifecycle(runtime.events), ['update', 'reset', 'ready']);
+        assert.equal(lastEvent(runtime.events).value, 'baseline');
+      });
+    }
+  },
+);
+
 test(
   'disposal during awaited behavior initialization suppresses refresh and ready callbacks',
   { concurrency: false },

package/zova/src/suite-vendor/a-zova/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zova-suite-a-zova",
-  "version": "5.1.167",
+  "version": "5.1.169",
   "gitHead": "2c5c19284bab738e492856189acb6fad74b8a7b7",
   "description": "zova",
   "license": "MIT",
@@ -15,7 +15,7 @@
     "zova-module-a-behaviors": "^5.1.22",
     "zova-module-a-command": "^5.1.35",
     "zova-module-a-fetch": "^5.1.25",
-    "zova-module-a-form": "^5.1.52",
+    "zova-module-a-form": "^5.1.54",
     "zova-module-a-icon": "^5.1.27",
     "zova-module-a-interceptor": "^5.1.31",
     "zova-module-a-logger": "^5.1.28",