cabloy 5.1.172 → 5.1.174

package/zova/src/suite/a-demo/modules/demo-basic/src/component/controllerBoundaryProbe/controller.tsx

@@ -0,0 +1,36 @@
+import { BeanControllerBase, IComponentOptions } from 'zova';
+import { Controller } from 'zova-module-a-bean';
+
+export interface ControllerControllerBoundaryProbeProps {
+  mode: 'success' | 'failure' | 'serverFailure';
+  delayMs?: number;
+}
+
+@Controller()
+export class ControllerControllerBoundaryProbe extends BeanControllerBase {
+  static $propsDefault = {
+    delayMs: 800,
+  };
+
+  static $componentOptions: IComponentOptions = {
+    boundary: { loading: { delay: 500 }, retry: true },
+  };
+
+  ready = false;
+
+  protected async __init__() {
+    await new Promise(resolve => setTimeout(resolve, this.$props.delayMs));
+    if (
+      this.$props.mode === 'failure' ||
+      (this.$props.mode === 'serverFailure' && process.env.SERVER)
+    ) {
+      throw new Error('Controller boundary probe initialization failed');
+    }
+    this.ready = true;
+  }
+
+  protected render() {
+    if (!this.ready) return null;
+    return <div>Controller boundary probe ready</div>;
+  }
+}

package/zova/src/suite/a-demo/modules/demo-basic/src/component/controllerBoundaryProbeInline/controller.tsx

@@ -0,0 +1,34 @@
+import { BeanControllerBase, IComponentOptions } from 'zova';
+import { Controller } from 'zova-module-a-bean';
+
+export interface ControllerControllerBoundaryProbeInlineProps {
+  mode: 'success' | 'failure' | 'serverFailure';
+  delayMs?: number;
+}
+
+@Controller()
+export class ControllerControllerBoundaryProbeInline extends BeanControllerBase {
+  static $propsDefault = {
+    delayMs: 800,
+  };
+
+  static $componentOptions: IComponentOptions = {
+    boundary: { loading: { delay: 500 }, renderMode: 'inline', retry: true },
+  };
+
+  ready = false;
+
+  protected async __init__() {
+    const props = this.$props as ControllerControllerBoundaryProbeInlineProps;
+    await new Promise(resolve => setTimeout(resolve, props.delayMs));
+    if (props.mode === 'failure' || (props.mode === 'serverFailure' && process.env.SERVER)) {
+      throw new Error('Inline Controller boundary probe initialization failed');
+    }
+    this.ready = true;
+  }
+
+  protected render() {
+    if (!this.ready) return null;
+    return <span>Inline Controller boundary probe ready</span>;
+  }
+}

package/zova/src/suite/a-demo/modules/demo-basic/src/component/controllerBoundaryProbeOverride/controller.tsx

@@ -0,0 +1,46 @@
+import type { VNodeChild } from 'vue';
+import type { TypeComponentBoundaryRenderMode } from 'zova';
+
+import { BeanControllerBase, IComponentOptions } from 'zova';
+import { Controller } from 'zova-module-a-bean';
+
+export interface ControllerControllerBoundaryProbeOverrideProps {
+  mode: 'success' | 'failure';
+  delayMs?: number;
+}
+
+@Controller()
+export class ControllerControllerBoundaryProbeOverride extends BeanControllerBase {
+  static $propsDefault = {
+    delayMs: 800,
+  };
+
+  static $componentOptions: IComponentOptions = {
+    boundary: { loading: { delay: 500 }, renderMode: 'inline' },
+  };
+
+  ready = false;
+
+  protected async __init__() {
+    const props = this.$props as ControllerControllerBoundaryProbeOverrideProps;
+    await new Promise(resolve => setTimeout(resolve, props.delayMs));
+    if (props.mode === 'failure') {
+      throw new Error('Override Controller boundary probe initialization failed');
+    }
+    this.ready = true;
+  }
+
+  protected renderLoading(renderMode: TypeComponentBoundaryRenderMode): VNodeChild {
+    return <span role="status">Override loading mode: {renderMode}</span>;
+  }
+
+  protected renderError(error: unknown): VNodeChild {
+    const message = error instanceof Error ? error.message : String(error);
+    return <span role="alert">Override legacy error: {message}</span>;
+  }
+
+  protected render() {
+    if (!this.ready) return null;
+    return <span>Override Controller boundary probe ready</span>;
+  }
+}

package/zova/src/suite/a-demo/modules/demo-basic/src/page/controllerBoundary/controller.tsx

@@ -0,0 +1,185 @@
+import { z } from 'zod';
+import { BeanControllerPageBase } from 'zova';
+import { Controller } from 'zova-module-a-bean';
+import { ZPage } from 'zova-module-home-base';
+
+import {
+  ZControllerBoundaryProbe,
+  ZControllerBoundaryProbeInline,
+  ZControllerBoundaryProbeOverride,
+} from '../../.metadata/index.jsx';
+
+export const ControllerPageControllerBoundarySchemaParams = z.object({});
+
+export const ControllerPageControllerBoundarySchemaQuery = z.object({
+  mode: z.enum(['serverFailure', 'inlineServerFailure']).optional(),
+});
+
+type ProbeMode = 'success' | 'failure' | 'serverFailure';
+type InlineProbeMode = 'success' | 'failure' | 'serverFailure';
+
+@Controller()
+export class ControllerPageControllerBoundary extends BeanControllerPageBase {
+  probe?: { mode: ProbeMode; delayMs: number };
+  inlineProbe?: { mode: InlineProbeMode; delayMs: number };
+  overrideProbe?: { mode: 'success' | 'failure'; delayMs: number };
+  probeKey = 0;
+  inlineProbeKey = 0;
+  overrideProbeKey = 0;
+
+  protected async __init__() {
+    if (this.$query.mode === 'serverFailure') {
+      this.probe = { mode: 'serverFailure', delayMs: 0 };
+    } else if (this.$query.mode === 'inlineServerFailure') {
+      this.inlineProbe = { mode: 'serverFailure', delayMs: 0 };
+    }
+  }
+
+  mountFastSuccess() {
+    this._mountProbe('success', 300);
+  }
+
+  mountFastFailure() {
+    this._mountProbe('failure', 300);
+  }
+
+  mountDelayedSuccess() {
+    this._mountProbe('success', 800);
+  }
+
+  mountFailingProbe() {
+    this._mountProbe('failure', 800);
+  }
+
+  prepareProbeRetrySuccess() {
+    if (!this.probe) return;
+    this.probe = { mode: 'success', delayMs: 800 };
+  }
+
+  clearProbe() {
+    this.probe = undefined;
+  }
+
+  mountInlineFailingProbe() {
+    this._mountInlineProbe('failure', 800);
+  }
+
+  prepareInlineRetrySuccess() {
+    if (!this.inlineProbe) return;
+    this.inlineProbe = { mode: 'success', delayMs: 800 };
+  }
+
+  clearInlineProbe() {
+    this.inlineProbe = undefined;
+  }
+
+  mountOverrideFailingProbe() {
+    this.overrideProbe = { mode: 'failure', delayMs: 800 };
+    this.overrideProbeKey++;
+  }
+
+  recoverOverrideWithDelayedSuccess() {
+    this.overrideProbe = { mode: 'success', delayMs: 800 };
+    this.overrideProbeKey++;
+  }
+
+  clearOverrideProbe() {
+    this.overrideProbe = undefined;
+  }
+
+  private _mountProbe(mode: ProbeMode, delayMs: number) {
+    this.probe = { mode, delayMs };
+    this.probeKey++;
+  }
+
+  private _mountInlineProbe(mode: InlineProbeMode, delayMs: number) {
+    this.inlineProbe = { mode, delayMs };
+    this.inlineProbeKey++;
+  }
+
+  protected render() {
+    return (
+      <ZPage>
+        <h1>Controller Boundary Manual Validation</h1>
+        <p>
+          Mount a fresh child Controller to exercise the global loading and error boundary
+          renderers.
+        </p>
+        <div class="flex flex-wrap gap-2">
+          <button class="btn btn-primary" onClick={() => this.mountFastSuccess()}>
+            Mount fast success probe
+          </button>
+          <button class="btn btn-error" onClick={() => this.mountFastFailure()}>
+            Mount fast failing probe
+          </button>
+          <button class="btn btn-primary" onClick={() => this.mountDelayedSuccess()}>
+            Mount delayed success probe
+          </button>
+          <button class="btn btn-error" onClick={() => this.mountFailingProbe()}>
+            Mount failing probe
+          </button>
+          <button class="btn btn-secondary" onClick={() => this.prepareProbeRetrySuccess()}>
+            Prepare probe retry success
+          </button>
+          <button class="btn" onClick={() => this.clearProbe()}>
+            Clear probe
+          </button>
+        </div>
+        <div class="mt-4">
+          {this.probe && (
+            <ZControllerBoundaryProbe
+              key={this.probeKey}
+              mode={this.probe.mode}
+              delayMs={this.probe.delayMs}
+            />
+          )}
+        </div>
+        <div class="mt-4">
+          <button class="btn btn-error" onClick={() => this.mountInlineFailingProbe()}>
+            Mount inline failing probe
+          </button>
+          <button class="btn btn-secondary ml-2" onClick={() => this.prepareInlineRetrySuccess()}>
+            Prepare inline retry success
+          </button>
+          <button class="btn ml-2" onClick={() => this.clearInlineProbe()}>
+            Clear inline probe
+          </button>
+          <p class="mt-2">
+            Inline boundary:{' '}
+            {this.inlineProbe && (
+              <ZControllerBoundaryProbeInline
+                key={this.inlineProbeKey}
+                mode={this.inlineProbe.mode}
+                delayMs={this.inlineProbe.delayMs}
+              />
+            )}
+          </p>
+        </div>
+        <div class="mt-4">
+          <button class="btn btn-error" onClick={() => this.mountOverrideFailingProbe()}>
+            Mount override failing probe
+          </button>
+          <button
+            class="btn btn-secondary ml-2"
+            onClick={() => this.recoverOverrideWithDelayedSuccess()}
+          >
+            Recover override with delayed success
+          </button>
+          <button class="btn ml-2" onClick={() => this.clearOverrideProbe()}>
+            Clear override probe
+          </button>
+          <p class="mt-2">
+            Override boundary:{' '}
+            {this.overrideProbe && (
+              <ZControllerBoundaryProbeOverride
+                key={this.overrideProbeKey}
+                mode={this.overrideProbe.mode}
+                delayMs={this.overrideProbe.delayMs}
+              />
+            )}
+          </p>
+        </div>
+      </ZPage>
+    );
+  }
+}

package/zova/src/suite/a-demo/modules/demo-basic/src/routes.ts

@@ -1,6 +1,7 @@
 import type { IModuleRoute } from 'zova-module-a-router';
 
 import { ZPageComponent } from './.metadata/page/component.js';
+import { ZPageControllerBoundary } from './.metadata/page/controllerBoundary.js';
 import { ZPageLocale } from './.metadata/page/locale.js';
 import { ZPageRoutedDialog } from './.metadata/page/routedDialog.js';
 import { ZPageRoutedDialogDetail } from './.metadata/page/routedDialogDetail.js';
@@ -89,4 +90,9 @@ export const routes: IModuleRoute[] = [
     component: ZPageRoutedDialogDetail,
     meta: { requiresAuth: false },
   },
+  {
+    path: 'controllerBoundary',
+    component: ZPageControllerBoundary,
+    meta: { requiresAuth: false, ssrProfile: 'public' },
+  },
 ];

package/zova/src/suite/a-home/modules/home-base/src/config/locale/en-us.ts

@@ -1,6 +1,7 @@
 export default {
   Home: 'Home',
   GoHome: 'Go Home',
+  Retry: 'Retry',
   LanguageEnglish: 'English',
   LanguageChinese: 'Chinese',
   VonaIntegratedSsr: 'Vona integrated SSR',

package/zova/src/suite/a-home/modules/home-base/src/config/locale/zh-cn.ts

@@ -1,6 +1,7 @@
 export default {
   Home: '主页',
   GoHome: '返回首页',
+  Retry: '重试',
   LanguageEnglish: '英语',
   LanguageChinese: '简体中文',
   VonaIntegratedSsr: 'Vona 集成式 SSR',

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

@@ -24,9 +24,6 @@ export class ModelStudent extends BeanModelBase {
         const res = await this.scope.api.trainingStudent.summary({ params: { id } });
         return res ?? null;
       },
-      meta: {
-        disableErrorEffect: true,
-      },
     });
   }
 

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

@@ -0,0 +1,58 @@
+{
+  "name": "zova-module-basic-button",
+  "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"
+  },
+  "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-button",
+  "zovaModule": {
+    "dependencies": {
+      "basic-app": "5.0.0",
+      "basic-commands": "5.0.0"
+    }
+  }
+}

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

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

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

@@ -0,0 +1,122 @@
+// eslint-disable
+/** controller: begin */
+export * from '../component/button/controller.jsx';
+
+import 'zova';
+declare module 'zova' {
+
+
+}
+declare module 'zova-module-basic-button' {
+
+        export interface ControllerButton {
+          /** @internal */
+          get scope(): ScopeModuleBasicButton;
+        }
+}
+/** controller: end */
+/** controller: begin */
+import type { ControllerButton } from '../component/button/controller.jsx';
+import 'zova';
+declare module 'zova' {
+  export interface IBeanRecordLocal {
+    'basic-button.controller.button': ControllerButton;
+  }
+}
+/** controller: end */
+
+/** components: begin */
+export * from './component/button.js';
+import { ZButton } from './component/button.js';
+export const components = {
+  'button': ZButton,
+};
+import 'zova';
+declare module 'zova' {
+export interface IComponentRecord {
+  'basic-button:button': ControllerButton;
+}
+export interface IZovaComponentRecord {
+  'basic-button:button': typeof ZButton;
+}
+}
+/** components: end */
+/** behavior: begin */
+export * from '../bean/behavior.perform.jsx';
+import { IBehaviorOptionsPerform } from '../bean/behavior.perform.jsx';
+import 'zova-module-a-behavior';
+declare module 'zova-module-a-behavior' {
+
+    export interface IBehaviorRecord {
+      'basic-button:perform': IBehaviorOptionsPerform;
+    }
+
+
+}
+declare module 'zova-module-basic-button' {
+
+        export interface BehaviorPerform {
+          /** @internal */
+          get scope(): ScopeModuleBasicButton;
+        }
+
+        export interface BehaviorPerform {
+          get $beanFullName(): 'basic-button.behavior.perform';
+          get $onionName(): 'basic-button:perform';
+          get $onionOptions(): IBehaviorOptionsPerform;
+        }
+}
+/** behavior: end */
+/** behavior: begin */
+import type { BehaviorPerform } from '../bean/behavior.perform.jsx';
+import 'zova';
+declare module 'zova' {
+  export interface IBeanRecordLocal {
+    'basic-button.behavior.perform': BehaviorPerform;
+  }
+}
+/** behavior: end */
+/** behaviors: begin */
+import 'vue';
+import 'vue/jsx-runtime';
+
+declare module 'vue' {
+  export interface InputHTMLAttributes {
+    'bs-basic-button-perform'?: IBehaviorOptionsPerform | '' | boolean;
+  }
+}
+
+declare module 'vue/jsx-runtime' {
+  namespace JSX {
+    // need define class/style in IntrinsicAttributes
+    export interface IntrinsicAttributes {
+      'bs-basic-button-perform'?: IBehaviorOptionsPerform | '' | boolean;
+    }
+  }
+}
+/** behaviors: end */
+/** scope: begin */
+import { BeanScopeBase, type BeanScopeUtil } from 'zova';
+import { Scope } from 'zova-module-a-bean';
+
+@Scope()
+export class ScopeModuleBasicButton extends BeanScopeBase {}
+
+export interface ScopeModuleBasicButton {
+  util: BeanScopeUtil;
+}
+
+import 'zova';
+declare module 'zova' {
+  export interface IBeanScopeRecord {
+    'basic-button': ScopeModuleBasicButton;
+  }
+
+
+
+
+
+
+}
+
+/** scope: end */

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

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

package/zova/src/suite/cabloy-basic/modules/basic-button/src/bean/behavior.perform.tsx

@@ -0,0 +1,103 @@
+import type { VNode } from 'vue';
+import type { IDecoratorBehaviorOptions, NextBehavior } from 'zova-module-a-behavior';
+
+import { isNavigationFailure } from '@cabloy/vue-router';
+import { createVNode } from 'vue';
+import { BeanBehaviorBase, Behavior } from 'zova-module-a-behavior';
+
+export interface IBehaviorPropsInputPerform {
+  'class'?: unknown;
+  'disabled'?: boolean | '' | 'true' | 'false';
+  'onClick'?: (e: MouseEvent) => unknown;
+  ['aria-busy']?: boolean | 'true' | 'false';
+}
+
+export interface IBehaviorPropsOutputPerform extends IBehaviorPropsInputPerform {
+  'disabled'?: boolean;
+  'onClick'?: (e: MouseEvent) => unknown;
+  ['aria-busy']?: boolean | 'true' | 'false';
+}
+
+export type TypeBehaviorOnError = (
+  error: unknown,
+  e: MouseEvent,
+) => boolean | void | Promise<boolean | void>;
+
+export interface IBehaviorOptionsPerform extends IDecoratorBehaviorOptions {
+  isLoading?: boolean;
+  onPerform?: (e: MouseEvent) => Promise<void> | void;
+  onError?: TypeBehaviorOnError;
+}
+
+@Behavior<IBehaviorOptionsPerform>()
+export class BehaviorPerform extends BeanBehaviorBase<
+  IBehaviorOptionsPerform,
+  IBehaviorPropsInputPerform,
+  IBehaviorPropsOutputPerform
+> {
+  private _isLoading = false;
+
+  protected render(
+    props: IBehaviorPropsInputPerform,
+    next: NextBehavior<IBehaviorPropsOutputPerform>,
+  ): VNode {
+    const isLoading = this._isLoading || this.$options.isLoading === true;
+    const propsPatch: IBehaviorPropsOutputPerform = {
+      ...props,
+      'class': isLoading ? [props.class, 'btn-disabled'] : props.class,
+      'disabled':
+        props.disabled === true || props.disabled === '' || props.disabled === 'true' || isLoading,
+      'aria-busy': isLoading || props['aria-busy'],
+      'onClick': e => this._handleClick(e, props.onClick),
+    };
+    const vnode = next(propsPatch);
+    if (!isLoading) return vnode;
+    const children = vnode.children;
+    return createVNode(vnode.type as any, vnode.props as any, [
+      createVNode('span', {
+        'class': 'loading loading-spinner loading-xs',
+        'aria-hidden': 'true',
+      }),
+      ...(Array.isArray(children)
+        ? children
+        : children === undefined || children === null
+          ? []
+          : [children]),
+    ]);
+  }
+
+  private _handleClick(e: MouseEvent, onClick?: (e: MouseEvent) => unknown) {
+    if (this._isLoading || this.$options.isLoading === true) return;
+    return this._perform(e, onClick);
+  }
+
+  private async _perform(e: MouseEvent, onClick?: (e: MouseEvent) => unknown) {
+    try {
+      this._isLoading = true;
+      await onClick?.(e);
+      await this.$options.onPerform?.(e);
+    } catch (error) {
+      if (isActionControlFlowError(error)) throw error;
+      const handled = await this.$options.onError?.(error, e);
+      if (handled === true) return;
+      await this.$performCommand('basic-commands:alert', {
+        type: 'error',
+        text: getActionErrorMessage(error),
+      });
+    } finally {
+      this._isLoading = false;
+    }
+  }
+}
+
+export function isActionControlFlowError(error: unknown) {
+  return isNavigationFailure(error) || [301, 302, 401, 600].includes(Number((error as any)?.code));
+}
+
+export function getActionErrorMessage(error: unknown) {
+  if (error && (typeof error === 'object' || typeof error === 'function')) {
+    const message = (error as { message?: unknown }).message;
+    if (message !== undefined && message !== null) return String(message);
+  }
+  return String(error);
+}