zova-core 5.0.110 → 5.0.113

package/src/core/context/context.ts

@@ -0,0 +1,38 @@
+import { ComponentInternalInstance, markRaw } from 'vue';
+import { ZovaApplication } from '../app/application.js';
+import { BeanContainer } from '../../bean/beanContainer.js';
+import { CtxMeta } from './meta.js';
+import { Cast } from '../../types/utils/cast.js';
+
+export class ZovaContext {
+  instance: ComponentInternalInstance;
+  app: ZovaApplication;
+  bean: BeanContainer;
+  meta: CtxMeta;
+  //config: ContextConfig;
+
+  constructor(instance: ComponentInternalInstance) {
+    markRaw(this);
+    instance.zova = this;
+    this.instance = instance;
+    this.app = instance.appContext.app.zova;
+    this.bean = BeanContainer.create(this.app, this);
+    this.meta = this.bean._newBeanSimple(CtxMeta, false);
+  }
+
+  /** @internal */
+  public dispose() {
+    this.meta.dispose();
+    Cast(this.instance).zova = null;
+    Cast(this).instance = null;
+    Cast(this).app = null;
+    Cast(this).bean = null;
+    Cast(this).meta = null;
+  }
+}
+
+declare module 'vue' {
+  export interface ComponentInternalInstance {
+    zova: ZovaContext;
+  }
+}

package/src/core/context/index.ts

@@ -0,0 +1,4 @@
+export * from './component.js';
+export * from './context.js';
+export * from './meta.js';
+export * from './util.js';

package/src/core/context/meta.ts

@@ -0,0 +1,26 @@
+import { RendererNode } from 'vue';
+import { BeanSimple } from '../../bean/beanSimple.js';
+import { CtxState } from './state.js';
+import { CtxUtil } from './util.js';
+import { CtxComponent } from './component.js';
+
+export class CtxMeta extends BeanSimple {
+  util: CtxUtil;
+  state: CtxState;
+  component: CtxComponent;
+
+  get el(): RendererNode {
+    return this.ctx.instance.vnode.el!;
+  }
+
+  protected __init__() {
+    this.util = this.bean._newBeanSimple(CtxUtil, false);
+    this.state = this.bean._newBeanSimple(CtxState, true);
+    this.component = this.bean._newBeanSimple(CtxComponent, false);
+  }
+
+  /** @internal */
+  public dispose() {
+    this.component.dispose();
+  }
+}

package/src/core/context/state.ts

@@ -0,0 +1,28 @@
+import { BeanSimple } from '../../bean/beanSimple.js';
+import { StateLock } from '../../utils/stateLock.js';
+
+let __id: number = 0;
+
+export class CtxState extends BeanSimple {
+  private _id: number;
+  private _inited: StateLock;
+  private _mounted: StateLock;
+
+  protected __init__() {
+    this._id = ++__id;
+    this._inited = StateLock.create();
+    this._mounted = StateLock.create();
+  }
+
+  get id() {
+    return this._id;
+  }
+
+  get inited() {
+    return this._inited;
+  }
+
+  get mounted() {
+    return this._mounted;
+  }
+}

package/src/core/context/util.ts

@@ -0,0 +1,20 @@
+import { setCurrentInstance } from '@cabloy/vue-runtime-core';
+import { pauseTracking, resetTracking } from '@vue/reactivity';
+import { BeanSimple } from '../../bean/beanSimple.js';
+
+export class CtxUtil extends BeanSimple {
+  instanceScope(fn, tracking?: boolean) {
+    const reset = setCurrentInstance(this.ctx.instance as any);
+    if (!tracking) {
+      pauseTracking();
+    }
+    try {
+      return fn();
+    } finally {
+      if (!tracking) {
+        resetTracking();
+      }
+      reset();
+    }
+  }
+}

package/src/core/index.ts

@@ -0,0 +1,5 @@
+export * from './app/index.js';
+export * from './component/index.js';
+export * from './context/index.js';
+export * from './resource.js';
+export * from './metadata.js';

package/src/core/metadata.ts

@@ -0,0 +1,54 @@
+import 'reflect-metadata';
+
+export type MetadataKey = symbol | string;
+
+export class AppMetadata {
+  defineMetadata<V>(metadataKey: MetadataKey, metadataValue: V, target: object) {
+    Reflect.defineMetadata(metadataKey, metadataValue, target);
+  }
+
+  getOwnMetadata<V>(metadataKey: MetadataKey, target: object): V | undefined {
+    return Reflect.getOwnMetadata(metadataKey, target);
+  }
+
+  getMetadata<V>(metadataKey: MetadataKey, target: object, prop?: MetadataKey): V | undefined {
+    if (prop) {
+      return Reflect.getMetadata(metadataKey, target, prop);
+    }
+    return Reflect.getMetadata(metadataKey, target);
+  }
+
+  getOwnMetadataArray<Entry>(metadataKey: MetadataKey, target: object): Array<Entry> {
+    let own: Array<Entry> | undefined = this.getOwnMetadata(metadataKey, target);
+    if (!own) {
+      const parent: Array<Entry> | undefined = this.getMetadata(metadataKey, target);
+      if (parent) {
+        own = parent.slice();
+      } else {
+        own = [];
+      }
+      this.defineMetadata(metadataKey, own, target);
+    }
+    return own;
+  }
+
+  getOwnMetadataMap<K extends PropertyKey, V>(metadataKey: MetadataKey, target): Record<K, V> {
+    let own: Record<K, V> | undefined = this.getOwnMetadata(metadataKey, target);
+    if (!own) {
+      const parent: Record<K, V> | undefined = this.getMetadata(metadataKey, target);
+      if (parent) {
+        own = Object.assign({}, parent);
+      } else {
+        own = {} as Record<K, V>;
+      }
+      this.defineMetadata(metadataKey, own, target);
+    }
+    return own;
+  }
+
+  getDesignType(target: object, prop?: MetadataKey) {
+    return this.getMetadata('design:type', target as any, prop);
+  }
+}
+
+export const appMetadata = new AppMetadata();

package/src/core/resource.ts

@@ -0,0 +1,186 @@
+import { isClass } from '../utils/isClass.js';
+import {
+  Constructable,
+  Functionable,
+  IDecoratorBeanOptionsBase,
+  IDecoratorUseOptionsBase,
+} from '../decorator/index.js';
+import { MetadataKey, appMetadata } from './metadata.js';
+import { IBeanRecord } from '../bean/type.js';
+import { BeanSimple } from '../bean/beanSimple.js';
+import { parseLastWord, skipLastWord, skipPrefix, splitWords } from '@cabloy/last-word';
+import { uuid } from '../utils/uuid.js';
+
+export const DecoratorBeanFullName = Symbol.for('Decorator#BeanFullName');
+export const DecoratorUse = Symbol.for('Decorator#Use');
+export const DecoratorBeanFullNameOfComposable = Symbol.for('Decorator#BeanFullNameOfComposable');
+
+export class AppResource extends BeanSimple {
+  beans: Record<string, IDecoratorBeanOptionsBase> = {};
+  aops: Record<string, IDecoratorBeanOptionsBase> = {};
+
+  addUse(target: object, options: IDecoratorUseOptionsBase) {
+    const uses = appMetadata.getOwnMetadataMap(DecoratorUse, target);
+    uses[options.prop] = options;
+    if (process.env.NODE_ENV === 'development') {
+      if (typeof options.prop === 'string' && !options.prop.startsWith('$$')) {
+        console.error(`inject prop name should start with $$: ${options.prop}`);
+      }
+    }
+  }
+
+  getUses(target: object): Record<MetadataKey, IDecoratorUseOptionsBase> | undefined {
+    return appMetadata.getMetadata(DecoratorUse, target);
+  }
+
+  addAop<T>(options: Partial<IDecoratorBeanOptionsBase<T>>) {
+    // bean
+    const beanOptions = this.addBean(options);
+    // aop
+    this.aops[beanOptions.beanFullName] = beanOptions;
+    // ok
+    return beanOptions;
+  }
+
+  addBean<T>(options: Partial<IDecoratorBeanOptionsBase<T>>) {
+    const { module, beanClass, virtual } = options;
+    // name
+    const { scene, name } = this._parseSceneAndBeanName(beanClass!, options.scene, options.name);
+    // uuid
+    const beanUuid = uuid();
+    // beanFullName
+    let beanFullName;
+    if (['local'].includes(scene)) {
+      beanFullName = beanUuid;
+    } else {
+      beanFullName = `${module}.${scene}.${name}`;
+    }
+    // moduleBelong
+    const moduleBelong = this._parseModuleBelong(module, beanClass, virtual);
+    // options
+    const beanOptions = {
+      ...options,
+      scene,
+      name,
+      beanUuid,
+      beanFullName,
+      moduleBelong,
+    } as IDecoratorBeanOptionsBase<T>;
+    beanOptions.__aopChains__ = null!;
+    beanOptions.__aopChainsKey__ = {};
+    // record
+    this.beans[beanOptions.beanFullName] = beanOptions;
+    // set metadata
+    appMetadata.defineMetadata(DecoratorBeanFullName, beanOptions.beanFullName, beanOptions.beanClass);
+    // ok
+    return beanOptions;
+  }
+
+  getBeanFullName<T>(A: Constructable<T>): string | undefined {
+    return appMetadata.getOwnMetadata(DecoratorBeanFullName, A);
+  }
+
+  getBeanFullNameOfComposable(beanComposable: Functionable | undefined): string | undefined {
+    if (!beanComposable) return;
+    if (!beanComposable[DecoratorBeanFullNameOfComposable]) {
+      beanComposable[DecoratorBeanFullNameOfComposable] = `useComposable.${uuid()}`;
+    }
+    return beanComposable[DecoratorBeanFullNameOfComposable];
+  }
+
+  getBean<T>(A: Constructable<T>): IDecoratorBeanOptionsBase<T> | undefined;
+  getBean<K extends keyof IBeanRecord>(beanFullName: K): IDecoratorBeanOptionsBase<IBeanRecord[K]> | undefined;
+  getBean<T>(beanFullName: string): IDecoratorBeanOptionsBase<T> | undefined;
+  getBean<T>(beanFullName: Constructable<T> | string): IDecoratorBeanOptionsBase<T> | undefined {
+    let fullName: string | undefined;
+    if (typeof beanFullName === 'function' && isClass(beanFullName)) {
+      fullName = appMetadata.getOwnMetadata(DecoratorBeanFullName, beanFullName);
+    } else {
+      fullName = beanFullName as string;
+    }
+    if (!fullName) return null!;
+    return this.beans[fullName] as IDecoratorBeanOptionsBase<T>;
+  }
+
+  _fixClassName(className: string) {
+    const ch = className.charAt(className.length - 1);
+    if (ch >= '0' && ch <= '9') return className.substring(0, className.length - 1);
+    return className;
+  }
+
+  _parseSceneAndBeanName<T>(
+    beanClass: Constructable<T>,
+    scene?: string,
+    name?: string,
+  ): { scene: string; name: string } {
+    if (scene && name) {
+      return { scene, name };
+    }
+    // bean class name
+    let beanClassName = this._fixClassName(beanClass.name);
+    // skip prefix: Bean
+    if (beanClassName.toLowerCase().startsWith('bean')) {
+      beanClassName = beanClassName.substring('bean'.length);
+    } else {
+      beanClassName = beanClassName;
+    }
+    // name
+    if (!name) {
+      if (scene) {
+        name = skipPrefix(beanClassName, scene, true)!;
+      } else {
+        name = parseLastWord(beanClassName, true)!;
+      }
+    }
+    // scene
+    if (!scene) {
+      scene = skipLastWord(beanClassName, name, true)!;
+      scene = splitWords(scene, true, '.')!;
+    }
+    // ok
+    return { scene, name };
+  }
+
+  _parseModuleBelong(module, beanClass, virtual) {
+    // not set when virtual
+    if (virtual) return;
+    // check parent
+    let moduleBelong;
+    let parent = Object.getPrototypeOf(beanClass);
+    while (parent) {
+      const beanOptions = this.getBean(parent);
+      if (beanOptions && beanOptions.moduleBelong) {
+        moduleBelong = beanOptions.moduleBelong;
+        break;
+      }
+      parent = Object.getPrototypeOf(parent);
+    }
+    // set to current when parent not set
+    if (!moduleBelong) {
+      moduleBelong = module;
+    }
+    return moduleBelong;
+  }
+
+  _getModuleBelong<T>(A: Constructable<T>): string | undefined;
+  _getModuleBelong<K extends keyof IBeanRecord>(beanFullName: K): string | undefined;
+  _getModuleBelong(beanFullName: string): string | undefined;
+  _getModuleBelong<T>(beanFullName: Constructable<T> | string): string | undefined {
+    const beanOptions = this.getBean(beanFullName as any);
+    return beanOptions?.moduleBelong;
+  }
+
+  _getModuleName<T>(A: Constructable<T>): string | undefined;
+  _getModuleName<K extends keyof IBeanRecord>(beanFullName: K): string | undefined;
+  _getModuleName(beanFullName: string): string | undefined;
+  _getModuleName<T>(beanFullName: Constructable<T> | string): string | undefined {
+    const beanOptions = this.getBean(beanFullName as any);
+    return beanOptions?.module;
+  }
+
+  findAopsMatched(_beanFullName: string): any[] {
+    return [];
+  }
+}
+
+export const appResource = new AppResource();

package/src/decorator/class/bean.ts

@@ -0,0 +1,19 @@
+import { appResource } from '../../core/resource.js';
+import { Cast } from '../../types/utils/cast.js';
+import { IDecoratorBeanOptions } from '../interface/beanOptions.js';
+import { Constructable } from '../type/constructable.js';
+
+export function Bean<T>(options?: IDecoratorBeanOptions): ClassDecorator {
+  return function (target) {
+    if (!options) options = {};
+    // add
+    appResource.addBean({
+      module: Cast(options).module,
+      scene: options.scene || 'bean',
+      name: options.name,
+      containerScope: options.containerScope,
+      markReactive: options.markReactive,
+      beanClass: target as unknown as Constructable<T>,
+    });
+  };
+}

package/src/decorator/class/index.ts

@@ -0,0 +1,12 @@
+export * from './bean.js';
+export * from './model.js';
+export * from './local.js';
+export * from './scope.js';
+export * from './store.js';
+export * from './style.js';
+export * from './theme.js';
+export * from './tool.js';
+export * from './use.js';
+export * from './useComposable.js';
+export * from './useScope.js';
+export * from './virtual.js';

package/src/decorator/class/local.ts

@@ -0,0 +1,18 @@
+import { appResource } from '../../core/resource.js';
+import { Cast } from '../../types/utils/cast.js';
+import { IDecoratorLocalOptions } from '../interface/beanOptions.js';
+import { Constructable } from '../type/constructable.js';
+
+export function Local<T>(options?: IDecoratorLocalOptions): ClassDecorator {
+  return function (target) {
+    if (!options) options = {};
+    // add
+    appResource.addBean({
+      module: Cast(options).module,
+      scene: 'local',
+      containerScope: options.containerScope,
+      markReactive: options.markReactive,
+      beanClass: target as unknown as Constructable<T>,
+    });
+  };
+}

package/src/decorator/class/model.ts

@@ -0,0 +1,18 @@
+import { appResource } from '../../core/resource.js';
+import { Cast } from '../../types/utils/cast.js';
+import { Constructable, IDecoratorModelOptions } from '../index.js';
+
+export function Model<T>(options?: IDecoratorModelOptions): ClassDecorator {
+  return function (target) {
+    if (!options) options = {};
+    // add
+    appResource.addBean({
+      module: Cast(options).module,
+      scene: options.scene || 'model',
+      name: options.name,
+      containerScope: 'ctx',
+      markReactive: options.markReactive,
+      beanClass: target as unknown as Constructable<T>,
+    });
+  };
+}

package/src/decorator/class/scope.ts

@@ -0,0 +1,18 @@
+import { appResource } from '../../core/resource.js';
+import { Cast } from '../../types/utils/cast.js';
+import { Constructable, IDecoratorScopeOptions } from '../index.js';
+
+export function Scope<T>(options?: IDecoratorScopeOptions): ClassDecorator {
+  return function (target) {
+    if (!options) options = {};
+    // add
+    appResource.addBean({
+      module: Cast(options).module,
+      scene: 'scope',
+      name: 'module', // force to the same name
+      containerScope: 'app',
+      markReactive: false,
+      beanClass: target as unknown as Constructable<T>,
+    });
+  };
+}

package/src/decorator/class/store.ts

@@ -0,0 +1,18 @@
+import { appResource } from '../../core/resource.js';
+import { Cast } from '../../types/utils/cast.js';
+import { Constructable, IDecoratorStoreOptions } from '../index.js';
+
+export function Store<T>(options?: IDecoratorStoreOptions): ClassDecorator {
+  return function (target) {
+    if (!options) options = {};
+    // add
+    appResource.addBean({
+      module: Cast(options).module,
+      scene: options.scene || 'store',
+      name: options.name,
+      containerScope: 'app',
+      markReactive: options.markReactive,
+      beanClass: target as unknown as Constructable<T>,
+    });
+  };
+}

package/src/decorator/class/style.ts

@@ -0,0 +1,18 @@
+import { appResource } from '../../core/resource.js';
+import { Cast } from '../../types/utils/cast.js';
+import { Constructable, IDecoratorStyleOptions } from '../index.js';
+
+export function Style<T>(options?: IDecoratorStyleOptions): ClassDecorator {
+  return function (target) {
+    if (!options) options = {};
+    // add
+    appResource.addBean({
+      module: Cast(options).module,
+      scene: options.scene || 'style',
+      name: options.name,
+      containerScope: 'app',
+      markReactive: options.markReactive,
+      beanClass: target as unknown as Constructable<T>,
+    });
+  };
+}

package/src/decorator/class/theme.ts

@@ -0,0 +1,18 @@
+import { appResource } from '../../core/resource.js';
+import { Cast } from '../../types/utils/cast.js';
+import { Constructable, IDecoratorThemeOptions } from '../index.js';
+
+export function Theme<T>(options?: IDecoratorThemeOptions): ClassDecorator {
+  return function (target) {
+    if (!options) options = {};
+    // add
+    appResource.addBean({
+      module: Cast(options).module,
+      scene: options.scene || 'theme',
+      name: options.name,
+      containerScope: 'app',
+      markReactive: options.markReactive,
+      beanClass: target as unknown as Constructable<T>,
+    });
+  };
+}

package/src/decorator/class/tool.ts

@@ -0,0 +1,18 @@
+import { appResource } from '../../core/resource.js';
+import { Cast } from '../../types/utils/cast.js';
+import { Constructable, IDecoratorToolOptions } from '../index.js';
+
+export function Tool<T>(options?: IDecoratorToolOptions): ClassDecorator {
+  return function (target) {
+    if (!options) options = {};
+    // add
+    appResource.addBean({
+      module: Cast(options).module,
+      scene: options.scene || 'tool',
+      name: options.name,
+      containerScope: 'app',
+      markReactive: options.markReactive,
+      beanClass: target as unknown as Constructable<T>,
+    });
+  };
+}

package/src/decorator/class/use.ts

@@ -0,0 +1,37 @@
+import { IBeanRecord } from '../../bean/type.js';
+import { appMetadata, MetadataKey } from '../../core/metadata.js';
+import { appResource } from '../../core/resource.js';
+import { Constructable, IDecoratorUseOptions } from '../index.js';
+
+export function Use(options?: IDecoratorUseOptions): PropertyDecorator;
+export function Use<T extends keyof IBeanRecord>(beanFullName?: T): PropertyDecorator;
+export function Use(options?: IDecoratorUseOptions | string): PropertyDecorator {
+  return function (target: object, prop: MetadataKey) {
+    if (!options) options = {};
+    if (typeof options === 'string') {
+      options = { beanFullName: options } as unknown as IDecoratorUseOptions;
+    }
+    // beanClass
+    const beanClass = appMetadata.getDesignType(target, prop) as Constructable;
+    // record
+    appResource.addUse(target, {
+      ...options,
+      prop,
+      beanClass,
+    });
+    // chech beanClass
+    if (process.env.NODE_ENV === 'development') {
+      const moduleSource = appResource._getModuleName(beanClass);
+      if (moduleSource) {
+        window.setTimeout(() => {
+          const moduleTarget = appResource._getModuleName(target.constructor as any);
+          if (moduleSource !== moduleTarget) {
+            console.error(
+              `inject class should be imported by type, such as: import type { ${appResource._fixClassName(beanClass.name)} } from 'zova-module-xxx-xxx'`,
+            );
+          }
+        }, 0);
+      }
+    }
+  };
+}

package/src/decorator/class/useComposable.ts

@@ -0,0 +1,16 @@
+import { MetadataKey } from '../../core/metadata.js';
+import { appResource } from '../../core/resource.js';
+import { Functionable, IDecoratorUseComposableOptions } from '../index.js';
+
+export function UseComposable(options: IDecoratorUseComposableOptions | Functionable): PropertyDecorator {
+  return function (target: object, prop: MetadataKey) {
+    if (typeof options === 'function') {
+      options = { beanComposable: options } as IDecoratorUseComposableOptions;
+    }
+    // record
+    appResource.addUse(target, {
+      ...options,
+      prop,
+    });
+  };
+}

package/src/decorator/class/useScope.ts

@@ -0,0 +1,21 @@
+import { IBeanScopeRecord } from '../../bean/type.js';
+import { MetadataKey } from '../../core/metadata.js';
+import { appResource } from '../../core/resource.js';
+import { IDecoratorUseScopeOptions } from '../index.js';
+
+export function UseScope(options: IDecoratorUseScopeOptions): PropertyDecorator;
+export function UseScope<T extends keyof IBeanScopeRecord>(module: T): PropertyDecorator;
+export function UseScope(options: IDecoratorUseScopeOptions | string): PropertyDecorator {
+  return function (target: object, prop: MetadataKey) {
+    if (typeof options === 'string') {
+      options = { module: options } as IDecoratorUseScopeOptions;
+    }
+    const beanFullName = `${options.module}.scope.module`;
+    // record
+    appResource.addUse(target, {
+      ...options,
+      prop,
+      beanFullName,
+    });
+  };
+}

package/src/decorator/class/virtual.ts

@@ -0,0 +1,20 @@
+import { appResource } from '../../core/resource.js';
+import { Cast } from '../../types/utils/cast.js';
+import { IDecoratorVirtualOptions } from '../interface/beanOptions.js';
+import { Constructable } from '../type/constructable.js';
+
+export function Virtual<T>(options?: IDecoratorVirtualOptions): ClassDecorator {
+  return function (target) {
+    if (!options) options = {};
+    // add
+    appResource.addBean({
+      module: Cast(options).module,
+      scene: options.scene || 'virtual',
+      name: options.name,
+      containerScope: options.containerScope,
+      markReactive: options.markReactive,
+      beanClass: target as unknown as Constructable<T>,
+      virtual: true,
+    });
+  };
+}

package/src/decorator/index.ts

@@ -0,0 +1,7 @@
+export * from './class/index.js';
+export * from './interface/beanOptions.js';
+export * from './interface/useOptions.js';
+export * from './type/constructable.js';
+export * from './type/containerScope.js';
+export * from './type/injectionScope.js';
+export * from './type/functionable.js';