cabloy 5.1.172 → 5.1.173

package/zova/packages-utils/babel-plugin-zova-behavior/src/index.ts

@@ -92,13 +92,16 @@ function createVisitor(context: ContextInfo) {
             ),
           );
           // -> ()=>{}
-          const children = (nodePath.container as any)?.children;
-          if (children && children.length > 0 && !_checkIfHasJsxExpression(children)) {
-            const expressionArray = t.arrayExpression();
-            expressionArray.elements = (nodePath.container as any)?.children;
-            const expressionSlot = t.arrowFunctionExpression([], expressionArray);
+          const children = (nodePath.container as t.JSXElement).children;
+          if (children.length > 0 && _shouldWrapChildrenInSlot(tag, children)) {
+            const expressionSlot = t.arrowFunctionExpression(
+              [],
+              t.arrayExpression([
+                t.jsxFragment(t.jsxOpeningFragment(), t.jsxClosingFragment(), children),
+              ]),
+            );
             const expressionSlotContainer = t.jsxExpressionContainer(expressionSlot);
-            (nodePath.container as any).children = [expressionSlotContainer];
+            (nodePath.container as t.JSXElement).children = [expressionSlotContainer];
           }
         }
       }
@@ -106,8 +109,18 @@ function createVisitor(context: ContextInfo) {
   };
 }
 
-function _checkIfHasJsxExpression(children: t.JSXElement[]) {
-  return children.some(node => t.isJSXExpressionContainer(node));
+function _shouldWrapChildrenInSlot(tag: t.Expression, children: t.JSXElement['children']) {
+  if (_hasExplicitDefaultSlotFunction(children)) return false;
+  return t.isStringLiteral(tag) || !children.some(child => t.isJSXExpressionContainer(child));
+}
+
+function _hasExplicitDefaultSlotFunction(children: t.JSXElement['children']) {
+  if (children.length !== 1) return false;
+  const [child] = children;
+  return (
+    t.isJSXExpressionContainer(child) &&
+    (t.isArrowFunctionExpression(child.expression) || t.isFunctionExpression(child.expression))
+  );
 }
 
 // bs-providerId-moduleName-beanName

package/zova/packages-utils/babel-plugin-zova-behavior/test/behaviorSlots.test.ts

@@ -0,0 +1,111 @@
+import { transformSync, traverse, types as t } from '@babel/core';
+import vueJsx from '@vue/babel-plugin-jsx';
+import { renderToString } from '@vue/server-renderer';
+import assert from 'node:assert/strict';
+import test from 'node:test';
+import { createVNode, Fragment } from 'vue';
+
+import behavior from '../src/index.ts';
+
+function transform(source: string) {
+  const result = transformSync(source, {
+    filename: 'fixture.tsx',
+    configFile: false,
+    babelrc: false,
+    ast: true,
+    plugins: [behavior, vueJsx],
+  });
+  assert.ok(result?.ast);
+  return result.ast;
+}
+
+function getBehaviorVNodeChildren(ast: t.File) {
+  let children: t.Expression | null | undefined;
+  traverse(ast, {
+    CallExpression(path) {
+      if (!t.isIdentifier(path.node.callee, { name: '_createVNode' })) return;
+      const [tag, , vnodeChildren] = path.node.arguments;
+      if (!t.isCallExpression(tag)) return;
+      if (!t.isIdentifier(tag.callee, { name: '_resolveComponent' })) return;
+      if (!t.isStringLiteral(tag.arguments[0], { value: 'ZBehavior__' })) return;
+      children = vnodeChildren as t.Expression | null | undefined;
+      path.stop();
+    },
+  });
+  assert.notEqual(children, undefined, 'should render ZBehavior__');
+  return children;
+}
+
+function getDefaultSlot(children: t.Expression | null | undefined) {
+  assert.ok(t.isObjectExpression(children), 'ZBehavior__ children should be a slot object');
+  const defaultSlot = children.properties.find(
+    property =>
+      t.isObjectProperty(property) &&
+      t.isIdentifier(property.key, { name: 'default' }) &&
+      t.isArrowFunctionExpression(property.value),
+  );
+  assert.ok(defaultSlot && t.isObjectProperty(defaultSlot));
+  assert.ok(t.isArrowFunctionExpression(defaultSlot.value));
+  return defaultSlot.value;
+}
+
+function getSlotFragmentChildren(defaultSlot: t.ArrowFunctionExpression) {
+  assert.ok(t.isArrayExpression(defaultSlot.body));
+  assert.equal(defaultSlot.body.elements.length, 1);
+  const [fragment] = defaultSlot.body.elements;
+  assert.ok(t.isCallExpression(fragment));
+  const children = fragment.arguments[2];
+  assert.ok(t.isArrayExpression(children));
+  return children.elements;
+}
+
+test('native behavior target wraps a dynamic child in a default slot', () => {
+  const ast = transform(
+    'const dom = <button bs-basic-button-perform={options}>{this.$slotDefault?.()}</button>;',
+  );
+  const defaultSlot = getDefaultSlot(getBehaviorVNodeChildren(ast));
+  const children = getSlotFragmentChildren(defaultSlot);
+  assert.equal(children.length, 1);
+  assert.ok(t.isOptionalCallExpression(children[0]));
+});
+
+test('native behavior target wraps static children in a default slot', () => {
+  const ast = transform('const dom = <button bs-basic-button-perform={options}>Delete</button>;');
+  const defaultSlot = getDefaultSlot(getBehaviorVNodeChildren(ast));
+  assert.equal(getSlotFragmentChildren(defaultSlot).length, 1);
+});
+
+test('native behavior target preserves an explicit default slot function', () => {
+  const ast = transform(
+    'const dom = <button bs-basic-button-perform={options}>{() => this.$slotDefault?.()}</button>;',
+  );
+  const defaultSlot = getDefaultSlot(getBehaviorVNodeChildren(ast));
+  assert.ok(t.isOptionalCallExpression(defaultSlot.body));
+});
+
+test('native behavior target without children does not create a default slot', () => {
+  const ast = transform('const dom = <button bs-basic-button-perform={options} />;');
+  assert.ok(t.isNullLiteral(getBehaviorVNodeChildren(ast)));
+});
+
+test('component behavior target keeps dynamic children as a default slot', () => {
+  const ast = transform(
+    'const dom = <VBtn bs-start-button-perform={options}>{this.$slotDefault?.()}</VBtn>;',
+  );
+  const defaultSlot = getDefaultSlot(getBehaviorVNodeChildren(ast));
+  assert.ok(t.isArrayExpression(defaultSlot.body));
+  assert.equal(defaultSlot.body.elements.length, 1);
+  assert.ok(t.isOptionalCallExpression(defaultSlot.body.elements[0]));
+});
+
+test('native targets render a default slot that returns an array', async () => {
+  const fragment = createVNode(Fragment, null, ['Delete']);
+  const html = await renderToString(createVNode('button', null, { default: () => [fragment] }));
+  assert.match(html, /Delete/);
+});
+
+test('native targets do not render a default slot that returns a bare Fragment', async () => {
+  const fragment = createVNode(Fragment, null, ['Delete']);
+  const html = await renderToString(createVNode('button', null, { default: () => fragment }));
+  assert.doesNotMatch(html, /Delete/);
+});

package/zova/packages-utils/zova-jsx/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zova-jsx",
-  "version": "1.1.89",
+  "version": "1.1.90",
   "gitHead": "2c5c19284bab738e492856189acb6fad74b8a7b7",
   "description": "Zova JSX",
   "keywords": [
@@ -50,7 +50,7 @@
     "@cabloy/word-utils": "^2.1.14",
     "typestyle": "^2.4.0",
     "vue": "^3.5.38",
-    "zova-core": "^5.1.89"
+    "zova-core": "^5.1.90"
   },
   "devDependencies": {
     "clean-package": "^2.2.0",

package/zova/packages-utils/zova-vite/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zova-vite",
-  "version": "1.1.45",
+  "version": "1.1.46",
   "gitHead": "09d901d17140a80ee0764211b441cda72fd94663",
   "description": "zova vite",
   "keywords": [
@@ -58,7 +58,7 @@
     "babel-plugin-transform-typescript-metadata": "^0.4.0",
     "babel-plugin-zova-bean-module": "^1.2.15",
     "babel-plugin-zova-bean-use": "^1.1.15",
-    "babel-plugin-zova-behavior": "^1.1.15",
+    "babel-plugin-zova-behavior": "^1.1.16",
     "babel-plugin-zova-component": "^1.1.15",
     "chalk": "^3.0.0",
     "esbuild": "^0.25.12",

package/zova/packages-zova/zova/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zova",
-  "version": "5.1.162",
+  "version": "5.1.163",
   "gitHead": "2c5c19284bab738e492856189acb6fad74b8a7b7",
   "description": "A vue3 framework with ioc",
   "keywords": [
@@ -45,8 +45,8 @@
     "postpack": "clean-package restore"
   },
   "dependencies": {
-    "zova-core": "^5.1.89",
-    "zova-suite-a-zova": "^5.1.161"
+    "zova-core": "^5.1.90",
+    "zova-suite-a-zova": "^5.1.162"
   },
   "devDependencies": {
     "clean-package": "^2.2.0",

package/zova/packages-zova/zova-core/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zova-core",
-  "version": "5.1.89",
+  "version": "5.1.90",
   "gitHead": "2c5c19284bab738e492856189acb6fad74b8a7b7",
   "description": "A vue3 framework with ioc",
   "keywords": [

package/zova/packages-zova/zova-core/src/bean/beanBase.ts

@@ -192,7 +192,7 @@ export class BeanBase extends BeanBaseSimple {
 
   protected $controllerMounted(fn: any) {
     return this.ctx.util.instanceScope(() => {
-      return this.ctx.meta.hooks.onMounted(fn);
+      return this.ctx.meta.hooks.onMounted(fn, this);
     });
   }
 

package/zova/packages-zova/zova-core/src/bean/beanContainer.ts

@@ -74,50 +74,90 @@ export class BeanContainer {
   /** @internal */
   public dispose() {
     const beanInstances = this[SymbolBeanContainerInstances];
-    for (const prop in beanInstances) {
-      if (prop.startsWith('$$')) continue;
-      const beanInstance = cast(beanInstances[prop]);
-      if (beanInstance && !(beanInstance instanceof BeanAopBase) && beanInstance.__dispose__) {
-        if (this.containerType === 'sys') {
-          this.sys.meta.module._monkeyModuleSync(
-            false,
-            'beanDispose',
-            undefined,
-            this,
-            beanInstance,
-          );
-          beanInstance.__dispose__();
-          this.sys.meta.module._monkeyModuleSync(
-            false,
-            'beanDisposed',
-            undefined,
-            this,
-            beanInstance,
-          );
-        } else {
-          this.app.meta.module._monkeyModuleSync(
-            false,
-            'beanDispose',
-            undefined,
-            this,
-            beanInstance,
-          );
+    let error: Error | undefined;
+    try {
+      for (const prop in beanInstances) {
+        if (prop.startsWith('$$')) continue;
+        const beanInstance = cast(beanInstances[prop]);
+        if (!beanInstance || beanInstance instanceof BeanAopBase || !beanInstance.__dispose__)
+          continue;
+        try {
+          if (this.containerType === 'sys') {
+            this.sys.meta.module._monkeyModuleSync(
+              false,
+              'beanDispose',
+              undefined,
+              this,
+              beanInstance,
+            );
+            beanInstance.__dispose__();
+            this.sys.meta.module._monkeyModuleSync(
+              false,
+              'beanDisposed',
+              undefined,
+              this,
+              beanInstance,
+            );
+          } else {
+            this.app.meta.module._monkeyModuleSync(
+              false,
+              'beanDispose',
+              undefined,
+              this,
+              beanInstance,
+            );
+            this.runWithInstanceScopeOrAppContext(() => {
+              return beanInstance.__dispose__();
+            });
+            this.app.meta.module._monkeyModuleSync(
+              false,
+              'beanDisposed',
+              undefined,
+              this,
+              beanInstance,
+            );
+          }
+        } catch (err) {
+          error ??= err as Error;
+        }
+      }
+    } finally {
+      this[SymbolBeanContainerInstances] = shallowReactive({});
+      this[SymbolBeanContainerParent] = undefined;
+      this[SymbolGetBeanSelectorInnerPromises] = {};
+    }
+    // eslint-disable no-throw-literal
+    if (error) throw error;
+  }
+
+  /** @internal */
+  public retryReset(ownedBeans: Set<object>) {
+    const beanInstances = this[SymbolBeanContainerInstances];
+    let error: Error | undefined;
+    try {
+      for (const prop in beanInstances) {
+        const beanInstance = cast(beanInstances[prop]);
+        if (!ownedBeans.has(beanInstance)) continue;
+        if (!beanInstance || beanInstance instanceof BeanAopBase || !beanInstance.__dispose__)
+          continue;
+        try {
           this.runWithInstanceScopeOrAppContext(() => {
             return beanInstance.__dispose__();
           });
-          this.app.meta.module._monkeyModuleSync(
-            false,
-            'beanDisposed',
-            undefined,
-            this,
-            beanInstance,
-          );
+        } catch (err) {
+          error ??= err as Error;
         }
       }
+    } finally {
+      for (const prop in beanInstances) {
+        if (ownedBeans.has(cast(beanInstances[prop]))) {
+          delete beanInstances[prop];
+        }
+      }
+      this[SymbolGetBeanSelectorInnerPromises] = {};
     }
-    this[SymbolBeanContainerInstances] = shallowReactive({});
-    this[SymbolBeanContainerParent] = undefined;
-    this[SymbolGetBeanSelectorInnerPromises] = {};
+    // eslint-disable no-throw-literal
+    if (error) throw error;
   }
 
   get containerType(): ContainerType {
@@ -355,6 +395,7 @@ export class BeanContainer {
       fullName,
       markReactive,
       withSelector,
+      undefined,
       ...args,
     );
   }
@@ -382,7 +423,16 @@ export class BeanContainer {
     markReactive?: boolean,
     ...args
   ): Promise<T> {
-    return await this._newBeanInner(false, null, null, beanFullName, markReactive, false, ...args);
+    return await this._newBeanInner(
+      false,
+      null,
+      null,
+      beanFullName,
+      markReactive,
+      false,
+      undefined,
+      ...args,
+    );
   }
 
   async _newBeanSelector<T>(
@@ -415,6 +465,7 @@ export class BeanContainer {
     beanFullName: Constructable<T> | string | undefined,
     markReactive?: boolean,
     withSelector?: boolean,
+    onBeanRecorded?: (beanInstance: T) => void,
     ...args
   ): Promise<T> {
     // bean options
@@ -432,6 +483,7 @@ export class BeanContainer {
           false,
           markReactive,
           withSelector,
+          onBeanRecorded,
         );
       }
       // throw new Error(`bean not found: ${beanFullName}`);
@@ -449,6 +501,7 @@ export class BeanContainer {
       // default is true: same as inject prop
       markReactive ?? beanOptions.markReactive ?? true,
       withSelector,
+      onBeanRecorded,
     );
   }
 
@@ -504,6 +557,7 @@ export class BeanContainer {
     aop: boolean | undefined,
     markReactive: boolean | undefined,
     withSelector?: boolean,
+    onBeanRecorded?: (beanInstance: T) => void,
   ): Promise<T> {
     // prepare
     const beanInstance = await this._prepareBeanInstance(
@@ -530,6 +584,7 @@ export class BeanContainer {
       if (recordProp) {
         this.__recordProp(recordProp, fullName, beanInstance, true);
       }
+      onBeanRecorded?.(beanInstance);
     }
     // init
     await this._initBeanInstance(beanFullName, beanInstance, args);
@@ -781,6 +836,7 @@ export class BeanContainer {
         targetBeanFullName,
         markReactive,
         selectorInfo.withSelector,
+        undefined,
         ...selectorInfo.args,
       );
     }

package/zova/packages-zova/zova-core/src/bean/resource/error/type.ts

@@ -1,5 +1,6 @@
 import type { ComponentPublicInstance } from 'vue';
 
+import type { ZovaContext } from '../../../core/context/context.ts';
 import type { IErrorObject } from './errorObject.ts';
 
 export const SymbolErrorInstanceInfo = Symbol('SymbolErrorInstanceInfo');
@@ -9,10 +10,18 @@ export interface IErrorInstanceInfo {
   info?: string;
 }
 
+export interface IErrorHandlerLoad {
+  readonly kind: 'controller-load';
+  readonly ctx: ZovaContext;
+  readonly originalError: unknown;
+  disposition: 'fallback' | 'handled';
+}
+
 export interface IErrorHandlerEventData {
   err: Error;
   instance?: ComponentPublicInstance | null;
   info?: string;
+  load?: IErrorHandlerLoad;
 }
 
 export type IErrorHandlerEventResult = Error | undefined;

package/zova/packages-zova/zova-core/src/bean/type.ts

@@ -85,8 +85,26 @@ export interface DefineModelOptions<T = any, G = T, S = T> {
   set?: (v: S) => any;
 }
 
+export type TypeComponentBoundaryRenderMode = 'block' | 'inline';
+export type TypeComponentBoundaryRetry = () => Promise<void>;
+
+export interface IComponentBoundaryLoadingOptions {
+  delay?: number;
+}
+
+export interface IComponentBoundaryOptions {
+  loading?: IComponentBoundaryLoadingOptions;
+  renderMode?: TypeComponentBoundaryRenderMode;
+  /**
+   * Declares that this Controller can safely construct a fresh load graph after a fallback error.
+   * It is disabled by default because Controller initialization may include non-idempotent work.
+   */
+  retry?: boolean;
+}
+
 export type IComponentOptions = Parameters<typeof defineOptions>[0] & {
   deepExtendDefault?: boolean;
+  boundary?: IComponentBoundaryOptions;
 };
 
 export type IEmit = () => void;

package/zova/packages-zova/zova-core/src/components/component.ts

@@ -9,11 +9,12 @@ export function createZovaComponentPage<M, R, S>(
   controller: Constructable<M>,
   render?: Constructable<R>,
   style?: Constructable<S>,
+  componentOptions?: IComponentOptions,
 ) {
   return defineComponent(() => {
     useControllerPage(controller, render, style);
     return () => {};
-  });
+  }, prepareComponentOptions(componentOptions));
 }
 
 export function prepareComponentOptions(componentOptions?: IComponentOptions) {