@oinone/kunlun-vue-widget 6.4.9 → 7.2.0

package/src/basic/Widget.ts

@@ -1,4 +1,4 @@
-import { IWidget, WidgetConstructor, WidgetProps } from '@oinone/kunlun-engine';
+import type { IWidget, WidgetConstructor, WidgetProps } from '@oinone/kunlun-engine';
 import { instantiate } from '@oinone/kunlun-shared';
 import { BehaviorSubject, Subject, Subscription } from '@oinone/kunlun-state';
 import { InnerWidgetType } from '../typing/typing';
@@ -32,6 +32,8 @@ export interface WidgetBehaviorSubjection<T> extends BaseWidgetSubjection<T> {
 export type watcher<T> = { path: string; handler: (newVal: T, oldVal: T) => void; options?: { deep?: boolean } };
 export type HANDLE = string;
 
+type InjectionType = { name: typeof Widget; list: Map<string | Symbol, string> };
+
 export abstract class Widget<Props extends WidgetProps = WidgetProps, R = unknown> implements IWidget<Props> {
   private static widgetCount = 0;
 
@@ -223,10 +225,10 @@ export abstract class Widget<Props extends WidgetProps = WidgetProps, R = unknow
    */
   protected static Inject(injectName?: string | Symbol) {
     return <T extends Widget>(target: T, name: string) => {
-      let injection: { name: typeof Widget; list: Map<string | Symbol, string> } = Reflect.get(target, 'injection') || {
+      let injection = (Reflect.get(target, 'injection') || {
         name: this,
         list: new Map()
-      };
+      }) as InjectionType;
       if (injection.name !== target.constructor) {
         const oldInjection = injection;
         injection = { name: target.constructor as typeof Widget, list: new Map() };
@@ -260,10 +262,10 @@ export abstract class Widget<Props extends WidgetProps = WidgetProps, R = unknow
    */
   protected static Provide(provideName?: string | Symbol) {
     return <T extends Widget>(target: T, name: string) => {
-      let injection: { name: typeof Widget; list: Map<string | Symbol, string> } = Reflect.get(target, 'provider') || {
+      let injection = (Reflect.get(target, 'provider') || {
         name: this,
         list: new Map()
-      };
+      }) as InjectionType;
       if (injection.name !== (target.constructor as typeof Widget)) {
         const old = injection;
         injection = { name: target.constructor as typeof Widget, list: new Map() };
@@ -319,7 +321,7 @@ export abstract class Widget<Props extends WidgetProps = WidgetProps, R = unknow
     }
 
     const props = {};
-    const injection = (Reflect.get(this, 'injection') || { list: new Map() }).list as Map<string | Symbol, string>;
+    const injection = ((Reflect.get(this, 'injection') || { list: new Map() }) as InjectionType).list;
     const attrs = this.getAttributes();
 
     if (injection) {
@@ -378,7 +380,7 @@ export abstract class Widget<Props extends WidgetProps = WidgetProps, R = unknow
    * 包装发布者事件
    * 如果启动了作用域检查，那么发布的时候会携带发布者的widget实例
    **/
-  private wrapSubjectWithScope(subject: AnySubject, scope?: WidgetTypeKey): AnySubject {
+  private wrapSubjectWithScope(subject: AnySubject<any>, scope?: WidgetTypeKey): AnySubject {
     if (!scope) {
       return subject;
     }
@@ -763,7 +765,7 @@ export abstract class Widget<Props extends WidgetProps = WidgetProps, R = unknow
   }
 
   private releaseInjection() {
-    const injection: { list: Map<string | Symbol, string> } = Reflect.get(this, 'injection');
+    const injection = Reflect.get(this, 'injection') as InjectionType;
     if (injection) {
       injection.list.forEach((name) => {
         const widget = this.getSelf()!;
@@ -778,7 +780,7 @@ export abstract class Widget<Props extends WidgetProps = WidgetProps, R = unknow
   }
 
   public getComputeHandler(name: string) {
-    return Reflect.get(this, `$compute$${name}`);
+    return Reflect.get(this, `$compute$${name}`) as { get: Function; set: Function };
   }
 
   protected getProps() {

package/src/basic/__tests__/Widget.spec.ts

@@ -0,0 +1,82 @@
+import { Widget } from '../Widget';
+import type { WidgetBehaviorSubjection } from '../Widget';
+
+class TestWidget extends Widget<{ value: number }, null> {
+  @Widget.Reactive({ displayName: 'displayValue' })
+  public value = 0;
+
+  @Widget.Method('increment')
+  public increment() {
+    this.value += 1;
+    return this.value;
+  }
+
+  @Widget.Watch('displayValue')
+  public onValueChange() {}
+
+  public render() {
+    return null;
+  }
+}
+
+const behaviorIdentifier = Symbol('behavior-sub-context');
+
+class BehaviorWidget extends Widget<{}, null> {
+  @Widget.BehaviorSubContext(behaviorIdentifier)
+  public channel!: WidgetBehaviorSubjection<{ value: string }>;
+
+  public render() {
+    return null;
+  }
+}
+
+describe('Widget 基类', () => {
+  it('Reactive/Method 装饰器应注册属性元数据', () => {
+    const widget = new TestWidget().initialize({ value: 1 } as any) as TestWidget;
+    const attrs = widget.getAttributes();
+    const props = (widget as any).getProps();
+
+    expect(attrs.get('displayValue')).toBe('value');
+    expect(props).toContain('displayValue');
+
+    const handle = widget.getHandle();
+    const selected = Widget.select<TestWidget>(handle);
+    expect(selected).toBe(widget);
+  });
+
+  it('Watch 装饰器应注册监听配置', () => {
+    const widget = new TestWidget().initialize({ value: 1 } as any) as TestWidget;
+    const watchers = widget.getWatchers();
+
+    expect(watchers.length).toBeGreaterThan(0);
+    expect(watchers.some((w) => w.path === 'displayValue')).toBe(true);
+  });
+
+  it('dispose 应从全局注册表中移除实例', () => {
+    const widget = new TestWidget().initialize({ value: 1 } as any) as TestWidget;
+    const handle = widget.getHandle();
+
+    expect(Widget.select(handle)).toBe(widget);
+
+    widget.dispose();
+
+    expect(Widget.select(handle)).toBeUndefined();
+  });
+
+  it('BehaviorSubContext 应支持组件间通信', () => {
+    const publisher = new BehaviorWidget().initialize() as BehaviorWidget;
+    const subscriber = new BehaviorWidget().initialize() as BehaviorWidget;
+
+    const received: string[] = [];
+
+    subscriber.channel.subscribe((data) => {
+      if (data) {
+        received.push(data.value);
+      }
+    });
+
+    publisher.channel.subject.next({ value: 'hello' });
+
+    expect(received).toContain('hello');
+  });
+});

package/src/data/ActiveRecordsWidget.ts

@@ -1,28 +1,30 @@
 import {
-  ActiveRecord,
-  ActiveRecords,
+  type ActiveRecord,
+  type ActiveRecords,
   ActiveRecordsOperator,
-  DeleteActiveRecordsByEntityFunction,
-  DeleteActiveRecordsByEntityPredict,
-  DeleteActiveRecordsFunction,
-  FlushActiveRecordsFunction,
-  PushActiveRecordsFunction,
-  PushActiveRecordsPredict,
-  ReloadActiveRecordsFunction,
-  RuntimeRelationField,
+  type DeleteActiveRecordsByEntityFunction,
+  type DeleteActiveRecordsByEntityPredict,
+  type DeleteActiveRecordsFunction,
+  type FlushActiveRecordsFunction,
+  type PushActiveRecordsFunction,
+  type PushActiveRecordsPredict,
+  type ReloadActiveRecordsFunction,
+  type RuntimeRelationField,
   SubmitCacheManager,
-  UpdateActiveRecordsByEntityFunction,
-  UpdateActiveRecordsByEntityPredict,
-  UpdateActiveRecordsFunction,
-  UpdateEntity
+  type UpdateActiveRecordsByEntityFunction,
+  type UpdateActiveRecordsByEntityPredict,
+  type UpdateActiveRecordsFunction,
+  type UpdateEntity
 } from '@oinone/kunlun-engine';
 import { Widget } from '../basic';
-import { OioAnyViewState, useOioState } from '../state';
-import { PathWidget, PathWidgetProps } from './PathWidget';
+import { type OioAnyViewState, OioGlobalState, useOioState } from '../state';
+import { PathWidget, type PathWidgetProps } from './PathWidget';
 
 export interface ActiveRecordsWidgetProps extends PathWidgetProps {
   dataSource?: ActiveRecords | null;
   activeRecords?: ActiveRecords;
+  isInitViewState?: boolean;
+  viewState?: OioAnyViewState;
 }
 
 /**
@@ -31,6 +33,22 @@ export interface ActiveRecordsWidgetProps extends PathWidgetProps {
 export class ActiveRecordsWidget<
   Props extends ActiveRecordsWidgetProps = ActiveRecordsWidgetProps
 > extends PathWidget<Props> {
+  /**
+   * 全局状态，在 beforeMounted 后可获取到有效值
+   * @protected
+   */
+  protected globalState: OioGlobalState | undefined;
+
+  public getGlobalState(): OioGlobalState | undefined {
+    return this.globalState;
+  }
+
+  public setGlobalState(state: OioGlobalState) {
+    this.globalState = state;
+  }
+
+  protected isInitViewState?: boolean;
+
   /**
    * 视图级别状态, 在 beforeMounted 后可获取到有效值
    * @protected
@@ -47,9 +65,13 @@ export class ActiveRecordsWidget<
 
   public initialize(props: Props) {
     super.initialize(props);
-    const { dataSource, activeRecords } = props;
+    const { dataSource, activeRecords, viewState } = props;
     this.setCurrentDataSource(dataSource);
     this.setCurrentActiveRecords(activeRecords);
+    if (viewState) {
+      this.isInitViewState = props.isInitViewState ?? true;
+      this.setViewState(viewState);
+    }
     return this;
   }
 
@@ -587,8 +609,16 @@ export class ActiveRecordsWidget<
   protected $$beforeMount() {
     super.$$beforeMount();
     let isInitStatePosition = false;
-    if (!this.viewState) {
-      this.viewState = useOioState().viewState;
+    if (this.viewState) {
+      if (this.isInitViewState) {
+        isInitStatePosition = true;
+        this.$$initViewStatePosition(this.viewState);
+        this.$$initViewState(this.viewState);
+      }
+    } else {
+      const { globalState, viewState } = useOioState();
+      this.globalState = globalState;
+      this.viewState = viewState;
       if (this.viewState) {
         isInitStatePosition = true;
         this.$$initViewStatePosition(this.viewState);
@@ -600,8 +630,8 @@ export class ActiveRecordsWidget<
     }
   }
 
-  protected $$mounted() {
-    super.$$mounted();
+  protected $$mountedAfterProperties() {
+    super.$$mountedAfterProperties();
     if (this.viewState) {
       this.$$clearViewStatePosition(this.viewState);
       this.$$clearViewState(this.viewState);

package/src/data/PathWidget.ts

@@ -1,6 +1,6 @@
 import { isNil } from 'lodash-es';
 import { Widget } from '../basic';
-import { DslDefinitionWidgetProps, DslDefinitionWidget } from '../dsl';
+import { type DslDefinitionWidgetProps, DslDefinitionWidget } from '../dsl';
 
 export interface PathWidgetProps extends DslDefinitionWidgetProps {
   path?: string;

package/src/dsl/DslDefinitionWidget.ts

@@ -1,18 +1,17 @@
-import { getMergeConfig } from '@oinone/kunlun-config';
 import {
-  ComputeContext,
+  type ComputeContext,
   ComputeContextManager,
   ROOT_HANDLE,
-  RuntimeContext,
+  type RuntimeContext,
   RuntimeContextManager,
-  RuntimeModelField
+  type RuntimeModelField
 } from '@oinone/kunlun-engine';
-import { BooleanHelper, CSSClass, CSSStyle } from '@oinone/kunlun-shared';
+import { BooleanHelper, type CSSClass, type CSSStyle } from '@oinone/kunlun-shared';
 import { StyleHelper } from '@oinone/kunlun-vue-ui-common';
 import { isNil } from 'lodash-es';
 import { Widget } from '../basic';
-import { InvisibleSupported, isAllInvisible } from '../feature';
-import { DslRenderWidget, DslRenderWidgetProps } from './DslRenderWidget';
+import { type InvisibleSupported, isAllInvisible } from '../feature';
+import { DslRenderWidget, type DslRenderWidgetProps } from './DslRenderWidget';
 
 /**
  * dsl组件属性
@@ -183,7 +182,7 @@ export class DslDefinitionWidget<Props extends DslDefinitionWidgetProps = DslDef
 
   public get rootViewRuntimeContext(): { runtimeContext: RuntimeContext; fields: RuntimeModelField[] } {
     const fields: RuntimeModelField[] = [];
-    let targetRuntimeContext: RuntimeContext = this.rootRuntimeContext;
+    let targetRuntimeContext: RuntimeContext | undefined = this.rootRuntimeContext;
     let field = targetRuntimeContext?.parentContext?.field;
     while (field && targetRuntimeContext) {
       fields.push(field);
@@ -204,37 +203,15 @@ export class DslDefinitionWidget<Props extends DslDefinitionWidgetProps = DslDef
       field = parentRuntimeContext.field;
       targetRuntimeContext = nextTargetRuntimeContext;
     }
+    if (!targetRuntimeContext) {
+      throw new Error('Invalid target runtime context.');
+    }
     return {
       runtimeContext: targetRuntimeContext,
       fields
     };
   }
 
-  protected cacheConfigProxy;
-
-  protected getMergeConfig(...keys: string[]): Record<string, any> {
-    // dsl
-    // appConfig
-    // themeConfig
-    // runtime config ConfigHelper
-    if (this.cacheConfigProxy) {
-      return this.cacheConfigProxy;
-    }
-    const result = getMergeConfig(keys, {
-      defaultValue: undefined
-    });
-    this.cacheConfigProxy = new Proxy(this.getDsl(), {
-      get(target, prop) {
-        if (prop in target) {
-          return target[prop as keyof typeof target];
-        }
-        return result[prop as keyof typeof result];
-      }
-    });
-
-    return this.cacheConfigProxy;
-  }
-
   protected invisibleProcess(invisible: boolean | string) {
     return BooleanHelper.toBoolean(invisible);
   }

package/src/dsl/DslNodeWidget.ts

@@ -1,6 +1,6 @@
-import { DslDefinition, XMLTemplateParser } from '@oinone/kunlun-dsl';
-import { DslProps, RuntimeContext, RuntimeContextManager } from '@oinone/kunlun-engine';
-import { IDslNode } from '@oinone/kunlun-meta';
+import { type DslDefinition, XMLTemplateParser } from '@oinone/kunlun-dsl';
+import { type DslProps, type RuntimeContext, RuntimeContextManager } from '@oinone/kunlun-engine';
+import type { IDslNode } from '@oinone/kunlun-meta';
 import { isNil } from 'lodash-es';
 import { VueWidget, Widget } from '../basic';
 

package/src/dsl/DslRenderWidget.ts

@@ -1,6 +1,7 @@
-import { DslDefinition, DslSlots, DslSlotUtils, UnknownDslDefinition } from '@oinone/kunlun-dsl';
-import { WidgetProps } from '@oinone/kunlun-engine';
-import { Slots, VNode } from 'vue';
+import { getMergeConfig } from '@oinone/kunlun-config';
+import { type DslDefinition, type DslSlots, DslSlotUtils, UnknownDslDefinition } from '@oinone/kunlun-dsl';
+import type { WidgetProps } from '@oinone/kunlun-engine';
+import type { Slots, VNode } from 'vue';
 import { VueWidget, Widget } from '../basic';
 import { DslRender } from '../util';
 
@@ -40,6 +41,8 @@ export class DslRenderWidget<Props extends DslRenderWidgetProps = DslRenderWidge
   @Widget.Reactive()
   protected slotName: string | undefined;
 
+  protected renderProps: Props | undefined;
+
   protected supportedSlotNames!: string[];
 
   protected dslSlots: DslSlots | undefined;
@@ -48,6 +51,7 @@ export class DslRenderWidget<Props extends DslRenderWidgetProps = DslRenderWidge
 
   public initialize(props: Props) {
     super.initialize(props);
+    this.renderProps = props;
     this.internal = props.internal || false;
     this.template = props.template;
     this.slotName = props.slotName;
@@ -62,6 +66,31 @@ export class DslRenderWidget<Props extends DslRenderWidgetProps = DslRenderWidge
     return this.template || UnknownDslDefinition;
   }
 
+  protected cacheConfigProxy;
+
+  protected getMergeConfig(...keys: string[]): Record<string, any> {
+    // dsl
+    // appConfig
+    // themeConfig
+    // runtime config ConfigHelper
+    if (this.cacheConfigProxy) {
+      return this.cacheConfigProxy;
+    }
+    const result = getMergeConfig(keys, {
+      defaultValue: undefined
+    });
+    this.cacheConfigProxy = new Proxy(this.getDsl(), {
+      get(target, prop) {
+        if (prop in target) {
+          return target[prop as keyof typeof target];
+        }
+        return result[prop as keyof typeof result];
+      }
+    });
+
+    return this.cacheConfigProxy;
+  }
+
   public getSlotName() {
     return this.slotName;
   }

package/src/feature/__tests__/invisible-supported.spec.ts

@@ -0,0 +1,31 @@
+import { executeInvisible, isAllInvisible, type InvisibleSupported } from '../invisible-supported';
+
+describe('invisible-supported', () => {
+  it('executeInvisible: 不传或为 undefined 时返回 false', () => {
+    expect(executeInvisible(undefined)).toBe(false);
+    expect(executeInvisible({ invisible: undefined })).toBe(false);
+  });
+
+  it('executeInvisible: 布尔值时直接返回布尔值', () => {
+    expect(executeInvisible({ invisible: true })).toBe(true);
+    expect(executeInvisible({ invisible: false })).toBe(false);
+  });
+
+  it('executeInvisible: 函数时执行并返回结果', () => {
+    const supported: InvisibleSupported = {
+      invisible: () => true
+    };
+    expect(executeInvisible(supported)).toBe(true);
+  });
+
+  it('isAllInvisible: 空数组或 undefined 返回 true, 否则需全部为 invisible', () => {
+    expect(isAllInvisible(undefined)).toBe(true);
+    expect(isAllInvisible([])).toBe(true);
+    expect(
+      isAllInvisible([{ invisible: true } as InvisibleSupported, { invisible: () => true } as InvisibleSupported])
+    ).toBe(true);
+    expect(
+      isAllInvisible([{ invisible: true } as InvisibleSupported, { invisible: false } as InvisibleSupported])
+    ).toBe(false);
+  });
+});

package/src/hooks/__tests__/all-mounted.spec.ts

@@ -0,0 +1,41 @@
+import { mount } from '@vue/test-utils';
+import { defineComponent, h, nextTick } from 'vue';
+import { onAllMounted, reportAllMounted } from '../all-mounted';
+
+describe('onAllMounted & reportAllMounted', () => {
+  it('不传回调时应打印警告且不抛错', () => {
+    const warnSpy = jest.spyOn(console, 'warn').mockImplementation(() => {});
+    // @ts-expect-error
+    onAllMounted(undefined);
+    expect(warnSpy).toHaveBeenCalled();
+    warnSpy.mockRestore();
+  });
+
+  it('所有子组件挂载后应触发 allMounted 回调', async () => {
+    const allMounted = jest.fn();
+    const allMountedUpdate = jest.fn();
+
+    const Parent = defineComponent({
+      setup() {
+        onAllMounted({ allMounted, allMountedUpdate });
+        return () => h('div', [h(Child), h(Child)]);
+      }
+    });
+
+    const Child = defineComponent({
+      setup() {
+        reportAllMounted();
+        return () => h('div');
+      }
+    });
+
+    const wrapper = mount(Parent);
+
+    await nextTick();
+    expect(allMounted).toHaveBeenCalledTimes(1);
+
+    wrapper.unmount();
+    await nextTick();
+    expect(allMountedUpdate).toHaveBeenCalledTimes(0);
+  });
+});

package/src/hooks/all-mounted.ts

@@ -1,6 +1,6 @@
 import { isFunction, isNil } from 'lodash-es';
 
-import { inject, InjectionKey, onBeforeMount, onMounted, onUnmounted, provide } from 'vue';
+import { inject, type InjectionKey, onBeforeMount, onMounted, onUnmounted, provide } from 'vue';
 
 interface AllMountedContext {
   reportBeforeMount: (key: string) => void;

package/src/shim-translate.d.ts

@@ -1,7 +1,10 @@
 export {};
 
-declare module '@vue/runtime-core' {
+declare module 'vue' {
   interface ComponentCustomProperties {
-    $translate<T extends string | null | undefined = string | null | undefined>(text: T): T;
+    $translate<T extends string | null | undefined = string | null | undefined>(
+      text: T,
+      context?: Record<string, unknown>
+    ): T;
   }
 }

package/src/state/__tests__/state.spec.ts

@@ -0,0 +1,114 @@
+import { computed, createApp, defineComponent, h } from 'vue';
+import { ViewType } from '@oinone/kunlun-meta';
+import { useProviderMetaContext, useInjectMetaContext, defaultMetaContext } from '../context';
+import { clearViewState, createViewState, getViewState, setViewState } from '../view';
+import { globalState } from '../global';
+import { useOioState } from '../use-state';
+import { createActionBarState, getActionBarState, popAction, pushAction } from '../method/action';
+import { popField, pushField } from '../method/field';
+
+describe('state/context', () => {
+  it('useProviderMetaContext/ useInjectMetaContext 应合并默认值和传入状态', () => {
+    let ctx: ReturnType<typeof useInjectMetaContext> | undefined;
+
+    const App = defineComponent({
+      setup() {
+        useProviderMetaContext({});
+        return () =>
+          h(
+            defineComponent({
+              setup() {
+                ctx = useInjectMetaContext();
+                return () => null;
+              }
+            })
+          );
+      }
+    });
+
+    const app = createApp(App);
+    const container = document.createElement('div');
+    app.mount(container);
+
+    expect(ctx).toBeDefined();
+    expect(ctx!.viewType.value).toBe(defaultMetaContext.viewType.value);
+    expect(ctx!.model.value).toBe(defaultMetaContext.model.value);
+
+    app.unmount();
+  });
+});
+
+describe('state/view & use-state', () => {
+  it('createViewState/ setViewState/ getViewState/ clearViewState 应维护视图状态', () => {
+    const handle = 'view-handle';
+    const state = createViewState(handle);
+    expect(state.handle).toBe(handle);
+
+    setViewState(state);
+    expect(getViewState(handle)).toBe(state);
+
+    const cleared = clearViewState(handle);
+    expect(cleared).toBe(state);
+    expect(getViewState(handle)).toBeUndefined();
+  });
+
+  it('useOioState 不带 handle 时返回全局状态和当前 viewState 方法', () => {
+    const handle = 'view-handle-2';
+    const state = createViewState(handle);
+    setViewState(state);
+
+    const result = useOioState();
+    expect(result.globalState).toBe(globalState);
+    expect(result.viewState).toBeUndefined();
+    expect(typeof result.createViewState).toBe('function');
+  });
+
+  it('useOioState 带 handle 时返回该视图的快捷操作函数', () => {
+    const handle = 'view-handle-3';
+    const state = createViewState(handle);
+    setViewState(state);
+
+    const result = useOioState(handle);
+    expect(result.globalState).toBe(globalState);
+    expect(result.viewState).toBe(state);
+
+    const newState = result.createViewState();
+    expect(newState.handle).toBe(handle);
+    expect(result.getViewState()).toBe(newState);
+
+    const removed = result.clearViewState();
+    expect(removed).toBe(newState);
+    expect(result.getViewState()).toBeUndefined();
+  });
+});
+
+describe('state/method/action', () => {
+  it('createActionBarState/getActionBarState/pushAction/popAction 应正确维护动作条', () => {
+    const viewState = createViewState('action-view');
+    const actionBar = createActionBarState.call(viewState, { handle: 'action-view' });
+    (viewState as any).actionBar = actionBar;
+
+    const currentActionBar = getActionBarState.call(viewState);
+    expect(currentActionBar).toBe(actionBar);
+
+    pushAction.call(viewState, 'action1');
+    expect(actionBar.actions).toContain('action1');
+
+    popAction.call(viewState, 'action1');
+    expect(actionBar.actions).not.toContain('action1');
+  });
+});
+
+describe('state/method/field', () => {
+  it('pushField/popField 应维护字段集合', () => {
+    const viewState = createViewState('field-view');
+    (viewState as any).fields = [];
+    (viewState as any).viewType = ViewType.Table;
+
+    pushField.call(viewState, 'field1');
+    expect(viewState.fields).toContain('field1');
+
+    popField.call(viewState, 'field1');
+    expect(viewState.fields).not.toContain('field1');
+  });
+});

package/src/state/context.ts

@@ -1,5 +1,5 @@
 import { ViewType } from '@oinone/kunlun-meta';
-import { computed, ComputedRef, inject, InjectionKey, provide } from 'vue';
+import { computed, type ComputedRef, inject, type InjectionKey, provide } from 'vue';
 
 /**
  * 元数据上下文
@@ -53,5 +53,9 @@ export const useProviderMetaContext = (state: Partial<MetaContext>): void => {
  * 获取元数据上下文
  */
 export const useInjectMetaContext = (): MetaContext => {
-  return inject(MetaContextKey, defaultMetaContext);
+  const res = inject(MetaContextKey, defaultMetaContext);
+  if (!res) {
+    return { ...defaultMetaContext };
+  }
+  return res;
 };