zova-core 5.0.110 → 5.0.113

package/src/core/app/meta.ts

@@ -0,0 +1,44 @@
+import { BeanSimple } from '../../bean/beanSimple.js';
+import { AppIcon } from '../../bean/resource/icon/icon.js';
+import { IModuleLocaleText } from '../../bean/resource/locale/type.js';
+import { Constructable } from '../../decorator/type/constructable.js';
+import { IMonkeyApp, IMonkeyController, IMonkeySystem } from '../../types/interface/monkey.js';
+import { AppError } from '../component/error.js';
+import { AppEvent } from '../component/event.js';
+import { AppComponent } from '../component/component.js';
+import { AppLocale } from '../component/locale.js';
+import { AppModule } from '../component/module.js';
+import { AppUtil } from './util.js';
+import { AppCookie } from '../component/cookie.js';
+
+export class AppMeta extends BeanSimple {
+  module: AppModule;
+  util: AppUtil;
+  component: AppComponent;
+  locale: AppLocale;
+  error: AppError;
+  event: AppEvent;
+  icon: AppIcon;
+  cookie: AppCookie;
+  text: IModuleLocaleText;
+
+  /** @internal */
+  public appMonkey?: IMonkeyApp & IMonkeySystem & IMonkeyController;
+
+  protected __init__() {
+    this.module = this.app.bean._newBeanSimple(AppModule, false);
+    this.util = this.app.bean._newBeanSimple(AppUtil, false);
+    this.component = this.app.bean._newBeanSimple(AppComponent, false);
+    this.locale = this.app.bean._newBeanSimple(AppLocale, false);
+    this.error = this.app.bean._newBeanSimple(AppError, false);
+    this.event = this.app.bean._newBeanSimple(AppEvent, false);
+    this.icon = this.app.bean._newBeanSimple(AppIcon, false);
+    this.cookie = this.app.bean._newBeanSimple(AppCookie, false);
+    this.text = this.locale.createLocaleText();
+  }
+
+  /** @internal */
+  public async initialize(AppMonkey: Constructable<IMonkeyApp & IMonkeySystem & IMonkeyController>) {
+    this.appMonkey = this.bean._newBeanSimple(AppMonkey, false);
+  }
+}

package/src/core/app/util.ts

@@ -0,0 +1,31 @@
+import { extend } from '@cabloy/extend';
+import { BeanSimple } from '../../bean/beanSimple.js';
+import { uuid } from '../../utils/uuid.js';
+
+export class AppUtil extends BeanSimple {
+  uuid(): string {
+    return uuid();
+  }
+
+  isUuid(str: string): boolean {
+    if (!str) return false;
+    const length = str.length;
+    return length === 36 || length === 32;
+  }
+
+  isNullOrEmptyString(str?: string | undefined | null): boolean {
+    return str === undefined || str === null || str === '';
+  }
+
+  async sleep(ms: number) {
+    return new Promise(reslove => {
+      window.setTimeout(() => {
+        reslove(null);
+      }, ms);
+    });
+  }
+
+  extend(...args) {
+    return extend(true, ...args);
+  }
+}

package/src/core/component/component.ts

@@ -0,0 +1,44 @@
+import { BeanSimple } from '../../bean/beanSimple.js';
+import { TypeModuleResourceComponents } from '../../types/interface/module.js';
+import { Component, ComponentCustomOptions } from 'vue';
+
+export class AppComponent extends BeanSimple {
+  /** @internal */
+  public async initialize() {}
+
+  public createAsyncComponent(componentName: string) {
+    return () => {
+      return this.use(componentName);
+    };
+    // should not use defineAsyncComponent
+    // return defineAsyncComponent(() => {
+    //   return this.use(componentName);
+    // });
+  }
+
+  public async use(componentName: string): Promise<Component> {
+    const [moduleName, componentName2] = componentName.split(':');
+    const module = await this.app.meta.module.use(moduleName);
+    return module.resource.components[componentName2];
+  }
+
+  /** @internal */
+  public _registerComponents(_moduleName: string, components: TypeModuleResourceComponents) {
+    if (!components) return;
+    for (const key in components) {
+      const component = components[key];
+      this._setComponentGlobal(component);
+    }
+  }
+
+  private _setComponentGlobal(component: Component) {
+    // register
+    const options = component as ComponentCustomOptions;
+    if (component.name && options.meta?.global === true) {
+      if (!this.app.vue.component(component.name)) {
+        this.app.vue.component(component.name, component);
+      }
+    }
+    return component;
+  }
+}

package/src/core/component/cookie.ts

@@ -0,0 +1,16 @@
+import Cookies from 'js-cookie';
+import { BeanSimple } from '../../bean/beanSimple.js';
+
+export class AppCookie extends BeanSimple {
+  getItem(key: string): string | undefined {
+    return Cookies.get(key);
+  }
+
+  setItem(key: string, value: string): void {
+    Cookies.set(key, value);
+  }
+
+  removeItem(key: string): void {
+    Cookies.remove(key);
+  }
+}

package/src/core/component/error.ts

@@ -0,0 +1,18 @@
+import { ErrorClass } from '../../bean/resource/error/errorClass.js';
+import { IErrorObject } from '../../bean/resource/error/errorObject.js';
+import { IModuleError } from '../../bean/resource/error/type.js';
+
+export class AppError extends ErrorClass {
+  /** @internal */
+  public createScopeError(moduleScope: string, errorCode: number | string): IModuleError {
+    const self = this;
+    return {
+      throw: (...args: any[]): never => {
+        return self.throw(moduleScope, errorCode, ...args);
+      },
+      parseFail: (...args: any[]): IErrorObject => {
+        return self.parseFail(moduleScope, errorCode, ...args);
+      },
+    };
+  }
+}

package/src/core/component/event.ts

@@ -0,0 +1,87 @@
+import { composeAsync } from '@cabloy/compose';
+import { BeanSimple } from '../../bean/beanSimple.js';
+import {
+  IEventRecord,
+  IEventResultRecord,
+  TypeEventContext,
+  TypeEventHandler,
+  TypeEventHandlers,
+  TypeEventHandlersMap,
+  TypeEventOff,
+} from '../../types/interface/event.js';
+
+const __adapter = (_context, chain) => {
+  const eventHandlerWrapper = chain;
+  if (eventHandlerWrapper.fn === null) return;
+  return {
+    receiver: undefined,
+    fn: eventHandlerWrapper.fn,
+  };
+};
+
+export class AppEvent extends BeanSimple {
+  private eventHandlersMap = {} as TypeEventHandlersMap<keyof IEventRecord>;
+
+  /** @internal */
+  public async initialize() {}
+
+  public getEventHandlers<K extends keyof IEventRecord>(
+    eventName: K,
+  ): TypeEventHandlers<IEventRecord[K], IEventResultRecord[K]> {
+    let eventHandlers = this.eventHandlersMap[eventName];
+    if (!eventHandlers) {
+      eventHandlers = this.eventHandlersMap[eventName] = [] as any;
+    }
+    return eventHandlers;
+  }
+
+  async emit<K extends keyof IEventRecord>(
+    eventName: K,
+    data?: IEventRecord[K],
+    initialValue?: IEventResultRecord[K],
+    fallback?: TypeEventHandler<IEventRecord[K], IEventResultRecord[K]>,
+  ): Promise<IEventResultRecord[K]> {
+    const eventHandlers = this.getEventHandlers(eventName);
+    // context
+    const context = {
+      data,
+      result: initialValue,
+    } as TypeEventContext<IEventRecord[K], IEventResultRecord[K]>;
+    // invoke
+    await composeAsync(eventHandlers.concat(), __adapter)(context, async (context, next) => {
+      if (fallback) {
+        await fallback(context, next);
+      } else {
+        await next();
+      }
+    });
+    // ok
+    return context.result;
+  }
+
+  on<K extends keyof IEventRecord>(
+    eventName: K,
+    fn: TypeEventHandler<IEventRecord[K], IEventResultRecord[K]>,
+  ): TypeEventOff {
+    const eventHandlers = this.getEventHandlers(eventName);
+    eventHandlers.push({ fn });
+    return () => {
+      const index = eventHandlers.findIndex(item => item.fn === fn);
+      if (index > -1) {
+        eventHandlers[index].fn = null;
+        eventHandlers.splice(index, 1);
+      }
+    };
+  }
+
+  once<K extends keyof IEventRecord>(
+    eventName: K,
+    fn: TypeEventHandler<IEventRecord[K], IEventResultRecord[K]>,
+  ): TypeEventOff {
+    const off = this.on(eventName, async (context, next) => {
+      await fn(context, next);
+      off();
+    });
+    return off;
+  }
+}

package/src/core/component/index.ts

@@ -0,0 +1,3 @@
+export * from './error.js';
+export * from './locale.js';
+export * from './module.js';

package/src/core/component/locale.ts

@@ -0,0 +1,97 @@
+import * as localeutil from '@cabloy/localeutil';
+import { BeanSimple } from '../../bean/beanSimple.js';
+import { TypeModuleResourceLocaleModules, TypeModuleResourceLocales } from '../../types/interface/module.js';
+import { ILocalInfos, IModuleLocale, IModuleLocaleText } from '../../bean/resource/locale/type.js';
+import { ZovaLocaleOptionalMap } from '../app/locale.js';
+import { ref, Ref } from 'vue';
+
+const SymbolLocaleCurrent = Symbol('SymbolLocaleCurrent');
+
+export class AppLocale extends BeanSimple {
+  private [SymbolLocaleCurrent]: Ref<string | undefined> = ref();
+  /** @internal */
+  public locales: TypeModuleResourceLocales = {};
+  public localeModules: TypeModuleResourceLocaleModules = {};
+
+  get current(): keyof ILocalInfos {
+    let locale = this[SymbolLocaleCurrent].value;
+    if (!locale) locale = this.app.meta.cookie.getItem(this.app.config.locale.storeKey);
+    if (!locale) locale = this.app.config.locale.default;
+    return locale as keyof ILocalInfos;
+  }
+
+  set current(value: keyof ILocalInfos) {
+    if (this[SymbolLocaleCurrent].value === value) return;
+    this[SymbolLocaleCurrent].value = value;
+    this.app.meta.cookie.setItem(this.app.config.locale.storeKey, value);
+  }
+
+  /** @internal */
+  public async initialize(locales: ZovaLocaleOptionalMap) {
+    for (const locale in locales) {
+      const moduleMap = locales[locale].modules;
+      for (const moduleName in moduleMap) {
+        this._registerLocale(moduleName, locale, moduleMap[moduleName]);
+      }
+    }
+  }
+
+  /** @internal */
+  public _registerLocales(moduleName: string, locales: TypeModuleResourceLocales) {
+    if (!locales) return;
+    for (const locale in locales) {
+      this._registerLocale(moduleName, locale, locales[locale]);
+    }
+  }
+
+  private _registerLocale(moduleName: string, locale: string, moduleLocales: object) {
+    // locales
+    this.locales[locale] = Object.assign({}, moduleLocales, this.locales[locale]);
+    // localeModules
+    if (!this.localeModules[moduleName]) this.localeModules[moduleName] = {};
+    this.localeModules[moduleName][locale] = Object.assign({}, moduleLocales, this.localeModules[moduleName][locale]);
+  }
+
+  /** @internal */
+  public createLocaleText(moduleScope?: string): IModuleLocaleText {
+    const self = this;
+    const getText = function (text: string, ...args: any[]): string {
+      return self.getText(moduleScope, undefined, text, ...args);
+    };
+    getText.locale = function <T extends keyof ILocalInfos>(
+      locale: T | undefined,
+      text: string,
+      ...args: any[]
+    ): string {
+      return self.getText(moduleScope, locale, text, ...args);
+    };
+    return getText;
+  }
+
+  /** @internal */
+  public createScopeLocaleText(moduleScope: string, text: string): IModuleLocale {
+    const self = this;
+    const getText = function (...args: any[]): string {
+      return self.getText(moduleScope, undefined, text, ...args);
+    };
+    getText.locale = function <T extends keyof ILocalInfos>(locale: T | undefined, ...args: any[]): string {
+      return self.getText(moduleScope, locale, text, ...args);
+    };
+    return getText;
+  }
+
+  public getText<T extends keyof ILocalInfos>(
+    moduleScope: string | undefined,
+    locale: T | undefined,
+    key: string,
+    ...args: any[]
+  ): string {
+    return localeutil.getLocaleText(
+      moduleScope ? this.localeModules[moduleScope] : undefined,
+      this.locales,
+      locale || this.current,
+      key,
+      ...args,
+    );
+  }
+}

package/src/core/component/module.ts

@@ -0,0 +1,281 @@
+import { IModule, IModuleInfo } from '@cabloy/module-info';
+import * as ModuleInfo from '@cabloy/module-info';
+import { BeanSimple } from '../../bean/beanSimple.js';
+import { shallowReactive } from 'vue';
+import { IModuleResource, PluginZovaModulesMeta, SymbolInstalled, TypeMonkeyName } from '../../types/index.js';
+import { StateLock } from '../../utils/stateLock.js';
+import { TypeBeanScopeRecordKeys } from '../../bean/type.js';
+
+export class AppModule extends BeanSimple {
+  private modulesMeta: PluginZovaModulesMeta;
+  private modules: Record<string, IModule> = shallowReactive({});
+
+  /** @internal */
+  public async initialize(modulesMeta: PluginZovaModulesMeta) {
+    this.modulesMeta = modulesMeta;
+    await this._loadAllMonkeysAndSyncs();
+    await this._requireAllMonkeys();
+    await this._requireAllSyncs();
+  }
+
+  get<K extends TypeBeanScopeRecordKeys>(moduleName: K, forceLoad?: boolean): IModule | undefined;
+  get(moduleName: string, forceLoad?: boolean): IModule | undefined;
+  get(moduleName: IModuleInfo, forceLoad?: boolean): IModule | undefined;
+  get(moduleName: string | IModuleInfo, forceLoad?: boolean): IModule | undefined {
+    // module info
+    if (!moduleName) return undefined;
+    const moduleInfo = typeof moduleName === 'string' ? ModuleInfo.parseInfo(moduleName) : moduleName;
+    if (!moduleInfo) throw new Error(`invalid module name: ${moduleName}`);
+    // get
+    const module = this.modules[moduleInfo.relativeName];
+    if (!module) {
+      // module not loaded, so async use to raise the next call
+      if (forceLoad !== false) {
+        this.use(moduleInfo.relativeName);
+      }
+      return undefined;
+    }
+    if (!module[SymbolInstalled] || !module[SymbolInstalled].state) {
+      return undefined;
+    }
+    return module;
+  }
+
+  async use<K extends TypeBeanScopeRecordKeys>(moduleName: K): Promise<IModule>;
+  async use(moduleName: string): Promise<IModule>;
+  async use(moduleName: IModuleInfo): Promise<IModule>;
+  async use(moduleName?: string | IModuleInfo): Promise<IModule> {
+    // module info
+    if (!moduleName) throw new Error('should specify the module name');
+    const moduleInfo = typeof moduleName === 'string' ? ModuleInfo.parseInfo(moduleName) : moduleName;
+    if (!moduleInfo) throw new Error(`invalid module name: ${moduleName}`);
+    const relativeName = moduleInfo.relativeName;
+    // should not try check get directly
+    // const module = this.getOnly(relativeName);
+    // if (module) return module;
+    // module
+    const moduleRepo = this.modulesMeta.modules[relativeName];
+    if (!moduleRepo) throw new Error(`module not exists: ${relativeName}`);
+    // install
+    await this._install(relativeName, moduleRepo);
+    // ok
+    return moduleRepo;
+  }
+
+  exists<K extends TypeBeanScopeRecordKeys>(moduleName: K): boolean;
+  exists(moduleName: string): boolean;
+  exists(moduleName: IModuleInfo): boolean;
+  exists(moduleName: string | IModuleInfo): boolean {
+    // module info
+    if (!moduleName) return false;
+    const moduleInfo = typeof moduleName === 'string' ? ModuleInfo.parseInfo(moduleName) : moduleName;
+    if (!moduleInfo) throw new Error(`invalid module name: ${moduleName}`);
+    const moduleRepo = this.modulesMeta.modules[moduleInfo.relativeName];
+    return !!moduleRepo;
+  }
+
+  private async _loadAllMonkeysAndSyncs() {
+    const promises: Promise<IModuleResource>[] = [];
+    const moduleNames: string[] = [];
+    for (const moduleName of this.modulesMeta.moduleNames) {
+      const module = this.modulesMeta.modules[moduleName];
+      const info = module.info;
+      if (info.capabilities?.monkey || info.capabilities?.sync) {
+        const moduleResource = module.resource as any;
+        promises.push(moduleResource());
+        moduleNames.push(moduleName);
+      }
+    }
+    const modulesResource = await Promise.all(promises);
+    for (let i = 0; i < modulesResource.length; i++) {
+      const moduleName = moduleNames[i];
+      this.modulesMeta.modules[moduleName].resource = modulesResource[i];
+    }
+  }
+
+  private async _requireAllMonkeys() {
+    for (const moduleName of this.modulesMeta.moduleNames) {
+      const module = this.modulesMeta.modules[moduleName];
+      if (module.info.capabilities?.monkey) {
+        await this._install(moduleName, module);
+      }
+    }
+  }
+
+  private async _requireAllSyncs() {
+    for (const moduleName of this.modulesMeta.moduleNames) {
+      const module = this.modulesMeta.modules[moduleName];
+      if (module.info.capabilities?.sync) {
+        await this._install(moduleName, module);
+      }
+    }
+  }
+
+  private async _install(moduleName: string, module: IModule) {
+    if (!module[SymbolInstalled]) {
+      module[SymbolInstalled] = StateLock.create();
+    }
+    // check
+    if (this.modules[moduleName]) {
+      await module[SymbolInstalled].wait();
+      return;
+    }
+    // record
+    this.modules[moduleName] = module;
+    // install
+    await this._installInner(moduleName, module);
+    // installed
+    module[SymbolInstalled].touch();
+    // scope: should after [SymbolInstalled].touch
+    await this.app.bean._getBean(`${moduleName}.scope.module` as any, false);
+  }
+
+  private async _installInner(_moduleName: string, module: IModule) {
+    // load
+    if (typeof module.resource === 'function') {
+      const moduleResource = module.resource as any;
+      module.resource = await moduleResource();
+    }
+    // main / monkey
+    if (module.resource.Main) {
+      module.mainInstance = this.app.bean._newBeanSimple(module.resource.Main, false, module);
+    }
+    if (module.resource.Monkey) {
+      module.monkeyInstance = this.app.bean._newBeanSimple(module.resource.Monkey, false, module);
+    }
+    // monkey: moduleLoading
+    await this._monkeyModule('moduleLoading', module);
+    // register resources
+    await this._registerResources(module);
+    // monkey: moduleLoaded
+    await this._monkeyModule('moduleLoaded', module);
+  }
+
+  private async _registerResources(module: IModule) {
+    this._registerComponents(module);
+    this._registerLocales(module);
+    this._registerErrors(module);
+    this._registerConstants(module);
+    await this._registerConfig(module);
+  }
+
+  private _registerComponents(module: IModule) {
+    this.app.meta.component._registerComponents(module.info.relativeName, module.resource.components);
+  }
+
+  private _registerErrors(module: IModule) {
+    if (!module.resource.Errors) return;
+    this.app.meta.error.errors[module.info.relativeName] = module.resource.Errors;
+  }
+
+  private _registerLocales(module: IModule) {
+    this.app.meta.locale._registerLocales(module.info.relativeName, module.resource.locales);
+  }
+
+  private _registerConstants(module: IModule) {
+    if (!module.resource.constants) return;
+    const relativeName = module.info.relativeName;
+    this.app.constant.modules[relativeName] = this.app.meta.util.extend(
+      {},
+      module.resource.constants,
+      this.app.constant.modules[relativeName],
+    );
+  }
+
+  private async _registerConfig(module: IModule) {
+    if (!module.resource.config) return;
+    // config
+    const config = await module.resource.config(this.app);
+    // monkey
+    await this._monkeyModule('configLoaded', module, config);
+    // extend
+    const relativeName = module.info.relativeName;
+    this.app.config.modules[relativeName] = this.app.meta.util.extend(
+      {},
+      config,
+      this.app.config.modules[relativeName],
+    );
+  }
+
+  /** @internal */
+  public async _monkeyModule(monkeyName: TypeMonkeyName, moduleTarget?: IModule, ...monkeyData: any[]) {
+    // self: main
+    if (moduleTarget && moduleTarget.mainInstance && moduleTarget.mainInstance[monkeyName]) {
+      // @ts-ignore ignore
+      await this.app.vue.runWithContext(async () => {
+        await moduleTarget.mainInstance[monkeyName](...monkeyData);
+      });
+    }
+    // module monkey
+    for (const key of this.modulesMeta.moduleNames) {
+      const moduleMonkey: IModule = this.modulesMeta.modules[key];
+      if (moduleMonkey.info.capabilities?.monkey) {
+        if (moduleMonkey.monkeyInstance && moduleMonkey.monkeyInstance[monkeyName]) {
+          await this.app.vue.runWithContext(async () => {
+            if (moduleTarget === undefined) {
+              // @ts-ignore ignore
+              await moduleMonkey.monkeyInstance[monkeyName](...monkeyData);
+            } else {
+              // @ts-ignore ignore
+              await moduleMonkey.monkeyInstance[monkeyName](moduleTarget, ...monkeyData);
+            }
+          });
+        }
+      }
+    }
+    // app monkey
+    const appMonkey = this.app.meta.appMonkey;
+    if (appMonkey && appMonkey[monkeyName]) {
+      await this.app.vue.runWithContext(async () => {
+        if (moduleTarget === undefined) {
+          // @ts-ignore ignore
+          await appMonkey[monkeyName](...monkeyData);
+        } else {
+          // @ts-ignore ignore
+          await appMonkey[monkeyName](moduleTarget, ...monkeyData);
+        }
+      });
+    }
+  }
+
+  /** @internal */
+  public _monkeyModuleSync(monkeyName: TypeMonkeyName, moduleTarget?: IModule, ...monkeyData: any[]) {
+    // self: main
+    if (moduleTarget && moduleTarget.mainInstance && moduleTarget.mainInstance[monkeyName]) {
+      // @ts-ignore ignore
+      this.app.vue.runWithContext(() => {
+        moduleTarget.mainInstance[monkeyName](...monkeyData);
+      });
+    }
+    // module monkey
+    for (const key of this.modulesMeta.moduleNames) {
+      const moduleMonkey: IModule = this.modulesMeta.modules[key];
+      if (moduleMonkey.info.capabilities?.monkey) {
+        if (moduleMonkey.monkeyInstance && moduleMonkey.monkeyInstance[monkeyName]) {
+          this.app.vue.runWithContext(() => {
+            if (moduleTarget === undefined) {
+              // @ts-ignore ignore
+              moduleMonkey.monkeyInstance[monkeyName](...monkeyData);
+            } else {
+              // @ts-ignore ignore
+              moduleMonkey.monkeyInstance[monkeyName](moduleTarget, ...monkeyData);
+            }
+          });
+        }
+      }
+    }
+    // app monkey
+    const appMonkey = this.app.meta.appMonkey;
+    if (appMonkey && appMonkey[monkeyName]) {
+      this.app.vue.runWithContext(() => {
+        if (moduleTarget === undefined) {
+          // @ts-ignore ignore
+          appMonkey[monkeyName](...monkeyData);
+        } else {
+          // @ts-ignore ignore
+          appMonkey[monkeyName](moduleTarget, ...monkeyData);
+        }
+      });
+    }
+  }
+}

package/src/core/context/component.ts

@@ -0,0 +1,34 @@
+import { BeanRenderBase } from '../../bean/beanRenderBase.js';
+import { BeanSimple } from '../../bean/beanSimple.js';
+import { BeanRenderIdentifier } from '../../bean/type.js';
+import { Cast } from '../../types/utils/cast.js';
+
+export class CtxComponent extends BeanSimple {
+  private _bean_render_original: any;
+
+  activate() {
+    const self = this;
+    const instance = Cast(this.ctx.instance);
+    this._bean_render_original = instance.render;
+    instance.render = function (this, ...args) {
+      if (instance.isUnmounted) return;
+      if (!self.ctx.meta.state.inited.state) {
+        return self._bean_render_original.call(this, ...args);
+      }
+      const render: BeanRenderBase = self.ctx.bean._getBeanSyncOnly(BeanRenderIdentifier);
+      if (!render) {
+        return self._bean_render_original.call(this, ...args);
+        // throw new Error('render bean not found');
+      }
+      // need not use ctx.meta.util.instanceScope, since ctx.instance = getCurrentInstance()
+      return render.render();
+    };
+  }
+
+  /** @internal */
+  public dispose() {
+    const instance = Cast(this.ctx.instance);
+    instance.render = this._bean_render_original;
+    this._bean_render_original = null;
+  }
+}