zova-core 5.0.110 → 5.0.113

package/src/bean/resource/icon/zovaIcon.ts

@@ -0,0 +1,52 @@
+import { defineComponent } from 'vue';
+import { mergeProps, createVNode } from 'vue';
+import { useZovaIcon } from './useZovaIcon.js';
+
+export const ZovaIcon = defineComponent({
+  name: 'ZovaIcon',
+  inheritAttrs: true,
+  props: {
+    name: String,
+    href: String,
+    width: [String, Number],
+    height: [String, Number],
+    color: String,
+  },
+  setup(props, _ref2) {
+    const { iconInfo } = useZovaIcon(() => props.name);
+    return () => {
+      // href
+      let href = props.href;
+      if (!href) {
+        href = `#${iconInfo.value?.symbolId || ''}`;
+      }
+      // svgProps
+      const svgProps = mergeProps(
+        {
+          class: 'zova-icon__svg',
+          xmlns: 'http://www.w3.org/2000/svg',
+          viewBox: '0 0 24 24',
+          fill: 'currentColor',
+          role: 'img',
+          'aria-hidden': 'true',
+        },
+        {
+          width: props.width,
+          height: props.height,
+          style: {
+            color: props.color,
+          },
+        },
+      );
+      return createVNode('svg', svgProps, [
+        createVNode(
+          'use',
+          {
+            'xlink:href': href,
+          },
+          null,
+        ),
+      ]);
+    };
+  },
+});

package/src/bean/resource/index.ts

@@ -0,0 +1,8 @@
+export * from './component/index.js';
+export * from './config/index.js';
+export * from './constant/index.js';
+export * from './error/index.js';
+export * from './icon/index.js';
+export * from './locale/index.js';
+export * from './page/index.js';
+export * from './service/index.js';

package/src/bean/resource/locale/beanScopeLocale.ts

@@ -0,0 +1,22 @@
+import { IModuleLocale } from './type.js';
+import { BeanSimple } from '../../beanSimple.js';
+
+const BeanModuleScope = Symbol('BeanScopeLocale#ModuleScope');
+
+export class BeanScopeLocale extends BeanSimple {
+  // @ts-ignore: ignore
+  private [BeanModuleScope]: string;
+  private __instances: Record<string, IModuleLocale> = {};
+
+  constructor(moduleScope) {
+    super();
+    this[BeanModuleScope] = moduleScope;
+  }
+
+  protected __get__(prop) {
+    if (!this.__instances[prop]) {
+      this.__instances[prop] = this.app.meta.locale.createScopeLocaleText(this[BeanModuleScope], prop);
+    }
+    return this.__instances[prop];
+  }
+}

package/src/bean/resource/locale/index.ts

@@ -0,0 +1,2 @@
+export * from './beanScopeLocale.js';
+export * from './type.js';

package/src/bean/resource/locale/type.ts

@@ -0,0 +1,21 @@
+export interface IModuleLocale {
+  (...args: any[]): string;
+  locale: <T extends keyof ILocalInfos>(locale: T, ...args: any[]) => string;
+}
+
+export interface IModuleLocaleText {
+  (text: string, ...args: any[]): string;
+  locale: <T extends keyof ILocalInfos>(locale: T, text: string, ...args: any[]) => string;
+}
+
+export type TypeModuleLocales<T> = {
+  [prop in string & keyof T]: IModuleLocale;
+};
+
+export type TypeLocaleBase = 'zh-cn';
+
+export interface ILocalInfo {}
+export interface ILocalInfos {
+  'en-us': ILocalInfo;
+  'zh-cn': ILocalInfo;
+}

package/src/bean/resource/page/index.ts

@@ -0,0 +1 @@
+export * from './type.js';

package/src/bean/resource/page/type.ts

@@ -0,0 +1,12 @@
+import { z } from 'zod';
+
+export interface IPagePathRecord {}
+export interface IPageNameRecord {}
+
+export type TypePageParamsQuery<Q, P = unknown> = {
+  query?: Q;
+  params?: P;
+};
+
+export type TypePageSchema = { params?: z.ZodTypeAny; query: z.ZodTypeAny };
+export type TypePageSchemas = Record<string, TypePageSchema>;

package/src/bean/resource/service/beanScopeService.ts

@@ -0,0 +1,24 @@
+import { BeanSimple } from '../../beanSimple.js';
+
+const BeanModuleScope = Symbol('BeanScopeLocale#ModuleScope');
+
+export class BeanScopeService extends BeanSimple {
+  // @ts-ignore: ignore
+  private [BeanModuleScope]: string;
+  private __instances: Record<string, object> = {};
+
+  constructor(moduleScope) {
+    super();
+    this[BeanModuleScope] = moduleScope;
+  }
+
+  protected __get__(prop) {
+    if (!this.__instances[prop]) {
+      const module = this.app.meta.module.get(this[BeanModuleScope]);
+      const services = module!.resource.services;
+      if (!services || !services[prop]) return undefined;
+      this.__instances[prop] = services[prop](this.app);
+    }
+    return this.__instances[prop];
+  }
+}

package/src/bean/resource/service/index.ts

@@ -0,0 +1,2 @@
+export * from './beanScopeService.js';
+export * from './type.js';

package/src/bean/resource/service/type.ts

@@ -0,0 +1,8 @@
+import { ZovaApplication } from '../../../core/app/application.js';
+
+export type TypeModuleServices<T extends Record<string, (app: ZovaApplication) => object> | unknown> =
+  T extends Record<string, (app: ZovaApplication) => object>
+    ? {
+        [K in keyof T]: ReturnType<T[K]>;
+      }
+    : never;

package/src/bean/scope/beanScopeBase.ts

@@ -0,0 +1,74 @@
+import { BeanBaseSimple, SymbolModuleBelong } from '../beanBaseSimple.js';
+import { BeanScopeError } from '../resource/error/beanScopeError.js';
+import { BeanScopeService } from '../resource/service/beanScopeService.js';
+import { BeanScopeLocale } from '../resource/locale/beanScopeLocale.js';
+import { IModule } from '@cabloy/module-info';
+
+export { type IModule } from '@cabloy/module-info';
+
+const BeanModuleError = Symbol('BeanScopeBase#BeanModuleError');
+const BeanModuleLocale = Symbol('BeanScopeBase#BeanModuleLocale');
+const BeanModuleConfig = Symbol('BeanScopeBase#BeanModuleConfig');
+const BeanModuleConstant = Symbol('BeanScopeBase#BeanModuleConstant');
+const BeanModuleComponent = Symbol('BeanScopeBase#BeanModuleComponent');
+const BeanModuleService = Symbol('BeanScopeBase#BeanModuleService');
+
+export class BeanScopeBase extends BeanBaseSimple {
+  private [BeanModuleError]: BeanScopeError;
+  private [BeanModuleLocale]: BeanScopeLocale;
+  private [BeanModuleConfig]: unknown;
+  private [BeanModuleConstant]: unknown;
+  private [BeanModuleComponent]: unknown;
+  private [BeanModuleService]: unknown;
+
+  get module(): IModule {
+    return this.app.meta.module.get(this[SymbolModuleBelong]) as unknown as IModule;
+  }
+
+  protected __get__(prop) {
+    const moduleBelong = this[SymbolModuleBelong];
+    // error
+    if (prop === 'error') {
+      if (!this[BeanModuleError]) {
+        this[BeanModuleError] = this.bean._newBeanSimple(BeanScopeError, false, moduleBelong);
+      }
+      return this[BeanModuleError];
+    }
+    // locale
+    if (prop === 'locale') {
+      if (!this[BeanModuleLocale]) {
+        this[BeanModuleLocale] = this.bean._newBeanSimple(BeanScopeLocale, false, moduleBelong);
+      }
+      return this[BeanModuleLocale];
+    }
+    // config
+    if (prop === 'config') {
+      if (!this[BeanModuleConfig]) {
+        this[BeanModuleConfig] = this.app.config.modules[moduleBelong];
+      }
+      return this[BeanModuleConfig];
+    }
+    // constant
+    if (prop === 'constant') {
+      if (!this[BeanModuleConstant]) {
+        this[BeanModuleConstant] = this.app.constant.modules[moduleBelong];
+      }
+      return this[BeanModuleConstant];
+    }
+    // component
+    if (prop === 'component') {
+      if (!this[BeanModuleComponent]) {
+        const module = this.app.meta.module.get(moduleBelong);
+        this[BeanModuleComponent] = module!.resource.components;
+      }
+      return this[BeanModuleComponent];
+    }
+    // service
+    if (prop === 'service') {
+      if (!this[BeanModuleService]) {
+        this[BeanModuleService] = this.bean._newBeanSimple(BeanScopeService, false, moduleBelong);
+      }
+      return this[BeanModuleService];
+    }
+  }
+}

package/src/bean/scope/index.ts

@@ -0,0 +1,4 @@
+export * from './beanScopeBase.js';
+//export * from './beanScopeBean.js';
+//export * from './beanScopeScene.js';
+export * from './type.js';

package/src/bean/scope/type.ts

@@ -0,0 +1,23 @@
+import { TypeModuleConfig } from '../resource/config/type.js';
+import { TypeModuleErrors } from '../resource/error/type.js';
+import { TypeModuleLocales } from '../resource/locale/type.js';
+import { TypeModuleConstants } from '../resource/constant/type.js';
+import { ZovaApplication } from '../../core/app/application.js';
+import { TypeModuleComponents } from '../resource/component/type.js';
+import { TypeModuleServices } from '../resource/index.js';
+
+export type TypeModuleResource<
+  COMPONENTS,
+  CONFIG extends (app: ZovaApplication) => object,
+  ERRORS,
+  LOCALES,
+  CONSTANTS = object,
+  SERVICES = undefined,
+> = {
+  component: TypeModuleComponents<COMPONENTS>;
+  config: TypeModuleConfig<CONFIG>;
+  error: TypeModuleErrors<ERRORS>;
+  locale: TypeModuleLocales<LOCALES>;
+  constant: TypeModuleConstants<CONSTANTS>;
+  service: TypeModuleServices<SERVICES>;
+};

package/src/bean/type.ts

@@ -0,0 +1,31 @@
+/** bean merge: bean.instance */
+export interface IBeanRecord {}
+export type TypeBeanRecordKeys = keyof IBeanRecord;
+
+export interface IBeanScopeRecord {}
+export type TypeBeanScopeRecordKeys = keyof IBeanScopeRecord;
+
+export interface IBeanScopeConfig {}
+export type TypeBeanScopeConfigKeys = keyof IBeanScopeConfig;
+
+export interface IBeanScopeLocale {}
+export type TypeBeanScopeLocaleKeys = keyof IBeanScopeLocale;
+
+export interface IControllerDataContext {
+  attrs?: unknown;
+  emit?: unknown;
+  slots?: object;
+}
+
+export interface IControllerData {
+  props?: unknown;
+  context: IControllerDataContext;
+}
+
+export const BeanControllerIdentifier = '$$c';
+export const BeanRenderIdentifier = '$$r';
+export const BeanStyleIdentifier = '$$s';
+
+export function getBeanName<K extends keyof IBeanRecord>(beanFullName: K): K {
+  return beanFullName;
+}

package/src/composables/index.ts

@@ -0,0 +1,4 @@
+export * from './onControllerMounted.js';
+export * from './useApp.js';
+export * from './useContext.js';
+export * from './useController.js';

package/src/composables/onControllerMounted.ts

@@ -0,0 +1,12 @@
+import { useContext } from './useContext.js';
+
+export async function onControllerMounted(fn) {
+  const ctx = useContext();
+  if (!ctx) {
+    throw new Error('run in the invalid context');
+  }
+  await ctx.meta.state.mounted.wait();
+  if (fn) {
+    return await ctx.meta.util.instanceScope(fn);
+  }
+}

package/src/composables/useApp.ts

@@ -0,0 +1,7 @@
+import { getCurrentInstance } from 'vue';
+import { ZovaApplication } from '../core/index.js';
+
+export function useApp(): ZovaApplication {
+  const instance = getCurrentInstance();
+  return instance?.appContext.app.zova as ZovaApplication;
+}

package/src/composables/useContext.ts

@@ -0,0 +1,7 @@
+import { getCurrentInstance } from 'vue';
+import { ZovaContext } from '../core/context/context.js';
+
+export function useContext(): ZovaContext {
+  const instance = getCurrentInstance();
+  return instance?.zova as ZovaContext;
+}

package/src/composables/useController.ts

@@ -0,0 +1,125 @@
+import { getCurrentInstance, onBeforeUnmount, onUnmounted, queuePostFlushCb, useAttrs, useSlots } from 'vue';
+import { Constructable } from '../decorator/index.js';
+import { ZovaContext } from '../core/context/index.js';
+import {
+  BeanControllerIdentifier,
+  BeanRenderIdentifier,
+  BeanStyleIdentifier,
+  IBeanRecord,
+  IControllerData,
+} from '../bean/type.js';
+
+export function useControllerPage<M, R, S>(
+  controllerBeanFullName: Constructable<M>,
+  renderBeanFullName?: Constructable<R>,
+  styleBeanFullName?: Constructable<S>,
+);
+export function useControllerPage<
+  MK extends keyof IBeanRecord,
+  RK extends keyof IBeanRecord,
+  SK extends keyof IBeanRecord,
+>(controllerBeanFullName: MK, renderBeanFullName?: RK, styleBeanFullName?: SK);
+// not use type string for typed params
+//export function useControllerPage(controllerBeanFullName: string, renderBeanFullName?: string, styleBeanFullName?: string);
+export function useControllerPage(
+  controllerBeanFullName: Constructable | string,
+  renderBeanFullName?: Constructable | string,
+  styleBeanFullName?: Constructable | string,
+) {
+  // controllerData
+  const controllerData = { context: {} };
+  // use controller
+  _useController(controllerData, controllerBeanFullName, renderBeanFullName, styleBeanFullName);
+}
+
+export function useController<M, R, S>(
+  props: unknown | undefined,
+  emit: unknown | undefined,
+  controllerBeanFullName: Constructable<M>,
+  renderBeanFullName?: Constructable<R>,
+  styleBeanFullName?: Constructable<S>,
+);
+export function useController<MK extends keyof IBeanRecord, RK extends keyof IBeanRecord, SK extends keyof IBeanRecord>(
+  props: unknown | undefined,
+  emit: unknown | undefined,
+  controllerBeanFullName: MK,
+  renderBeanFullName?: RK,
+  styleBeanFullName?: SK,
+);
+// not use type string for typed params
+// export function useController(
+//   props: unknown | undefined,
+//   emit: unknown | undefined,
+//   controllerBeanFullName: string,
+//   renderBeanFullName?: string,
+//   styleBeanFullName?: string,
+// );
+export function useController(
+  props: unknown | undefined,
+  emit: unknown | undefined,
+  controllerBeanFullName: Constructable | string,
+  renderBeanFullName?: Constructable | string,
+  styleBeanFullName?: Constructable | string,
+) {
+  // attrs
+  const attrs = useAttrs();
+  // slots
+  const slots = useSlots();
+  // controllerData
+  const controllerData = { props, context: { attrs, slots, emit } };
+  // use controller
+  _useController(controllerData, controllerBeanFullName, renderBeanFullName, styleBeanFullName);
+}
+
+async function _useController(
+  controllerData: IControllerData,
+  controllerBeanFullName: Constructable | string,
+  renderBeanFullName?: Constructable | string,
+  styleBeanFullName?: Constructable | string,
+) {
+  // ctx
+  const ctx = new ZovaContext(getCurrentInstance()!);
+  // monkey
+  if (ctx.app) {
+    ctx.app.meta.module._monkeyModuleSync('controllerDataPrepare', undefined, controllerData);
+  }
+  // dispose
+  onBeforeUnmount(() => {
+    if (!ctx.bean) return;
+    // undefined better than null
+    setControllerRef(ctx, false);
+    if (ctx.bean !== ctx.app.bean) {
+      ctx.bean.dispose();
+    }
+  });
+  onUnmounted(() => {
+    if (!ctx.bean) return;
+    ctx.dispose();
+  });
+  // controller
+  //onMounted(async () => {
+  await ctx.bean._newBeanInner(true, BeanControllerIdentifier, controllerData, undefined, controllerBeanFullName, true);
+  if (styleBeanFullName) {
+    await ctx.bean._newBeanInner(true, BeanStyleIdentifier, undefined, undefined, styleBeanFullName, true);
+  }
+  if (renderBeanFullName) {
+    await ctx.bean._newBeanInner(true, BeanRenderIdentifier, undefined, undefined, renderBeanFullName, true);
+  }
+  ctx.meta.state.inited.touch();
+  ctx.meta.util.instanceScope(() => {
+    queuePostFlushCb(() => {
+      ctx.meta.state.mounted.touch();
+      setControllerRef(ctx, true);
+    });
+  });
+  //});
+}
+
+function setControllerRef(ctx: ZovaContext, on: boolean) {
+  const controller = ctx.bean?._getBeanSyncOnly(BeanControllerIdentifier) as any;
+  if (!controller) return;
+  // instanceScope useless for emit, because emiter and receiver not the same instance
+  if (controller.$props?.controllerRef) {
+    controller.$props.controllerRef(on ? controller : undefined);
+  }
+}

package/src/core/app/application.ts

@@ -0,0 +1,76 @@
+import { App, markRaw } from 'vue';
+import { BeanContainer } from '../../bean/beanContainer.js';
+import { AppMeta } from './meta.js';
+import { PluginZovaOptions } from '../../types/interface/pluginZova.js';
+import { ZovaConfig, configDefault } from './config.js';
+import { ZovaConstant, constantDefault } from './constant.js';
+import { Cast } from '../../types/utils/cast.js';
+import { ZovaContext } from '../context/context.js';
+
+export class ZovaApplication {
+  private reloadDelayTimer: number = 0;
+  vue: App;
+  bean: BeanContainer;
+  meta: AppMeta;
+  config: ZovaConfig;
+  constant: ZovaConstant;
+
+  constructor(vue: App, ctxRoot: ZovaContext) {
+    markRaw(this);
+    vue.zova = this;
+    this.vue = vue;
+    this.bean = ctxRoot.bean;
+    Cast(this.bean).app = this;
+    ctxRoot.app = this;
+    this.meta = this.bean._newBeanSimple(AppMeta, false);
+    Cast(ctxRoot.instance.appContext).reload = () => {
+      this.reloadDelay();
+    };
+  }
+
+  /** @internal */
+  public async initialize({ modulesMeta, AppMonkey, locales, config }: PluginZovaOptions) {
+    // monkey
+    await this.meta.initialize(AppMonkey);
+    // component
+    await this.meta.component.initialize();
+    // locales
+    await this.meta.locale.initialize(locales);
+    // errors
+    await this.meta.error.initialize();
+    // config
+    this.config = this.meta.util.extend({}, configDefault, config);
+    // constant
+    this.constant = constantDefault;
+    // module
+    await this.meta.module.initialize(modulesMeta);
+    // monkey: appInitialize
+    await this.meta.module._monkeyModule('appInitialize', undefined, this.bean);
+    // monkey: appInitialized
+    await this.meta.module._monkeyModule('appInitialized', undefined, this.bean);
+  }
+
+  public reload() {
+    window.location.reload();
+  }
+
+  public reloadDelay(cancel?: boolean) {
+    if (cancel) {
+      if (this.reloadDelayTimer !== 0) {
+        window.clearTimeout(this.reloadDelayTimer);
+        this.reloadDelayTimer = 0;
+      }
+    } else {
+      this.reloadDelay(true);
+      this.reloadDelayTimer = window.setTimeout(() => {
+        this.reload();
+      }, 100);
+    }
+  }
+}
+
+declare module 'vue' {
+  export interface App {
+    zova: ZovaApplication;
+  }
+}

package/src/core/app/config.ts

@@ -0,0 +1,68 @@
+import {
+  ZovaConfigEnv,
+  ZovaConfigMeta,
+  IBeanScopeConfig,
+  ILocalInfos,
+  PowerPartial,
+  IComponentLayoutRecord,
+  IBeanScopeRecord,
+} from '../../index.js';
+
+export const configDefault = {
+  meta: {},
+  env: {},
+  base: {
+    jwt: false,
+  },
+  api: {
+    baseURL: '',
+    prefix: '',
+  },
+  icon: {
+    defaultModule: 'home-icon',
+  },
+  locale: {
+    default: 'en-us',
+    storeKey: 'locale',
+    items: {
+      'en-us': 'English',
+      'zh-cn': 'Chinese',
+    },
+  },
+  layout: {
+    component: {
+      default: 'home-layout:layoutDefault',
+      empty: 'home-layout:layoutEmpty',
+    },
+  },
+  modules: {},
+};
+
+export type ZovaConfig = {
+  meta: ZovaConfigMeta;
+  env: ZovaConfigEnv;
+  base: {
+    jwt: boolean;
+  };
+  api: {
+    baseURL: string;
+    prefix: string;
+  };
+  icon: {
+    defaultModule: keyof IBeanScopeRecord;
+  };
+  locale: {
+    default: keyof ILocalInfos;
+    storeKey: string;
+    items: Record<keyof ILocalInfos, string>;
+  };
+  layout: {
+    component: {
+      default: keyof IComponentLayoutRecord;
+      empty: keyof IComponentLayoutRecord;
+    };
+  };
+  modules: IBeanScopeConfig;
+};
+
+export type ZovaConfigOptional = PowerPartial<ZovaConfig>;

package/src/core/app/constant.ts

@@ -0,0 +1,11 @@
+import { PowerPartial } from '../../index.js';
+
+export const constantDefault = {
+  modules: {},
+};
+
+export type ZovaConstant = {
+  modules: Record<string, object>;
+} & typeof constantDefault;
+
+export type ZovaConstantOptional = PowerPartial<ZovaConstant>;

package/src/core/app/index.ts

@@ -0,0 +1,6 @@
+export * from './application.js';
+export * from './config.js';
+export * from './constant.js';
+export * from './locale.js';
+export * from './meta.js';
+export * from './util.js';

package/src/core/app/locale.ts

@@ -0,0 +1,12 @@
+import { IBeanScopeLocale, PowerPartial } from '../../index.js';
+
+export const localeDefault = {
+  modules: {},
+};
+
+export type ZovaLocale = {
+  modules: IBeanScopeLocale;
+} & typeof localeDefault;
+
+export type ZovaLocaleOptional = PowerPartial<ZovaLocale>;
+export type ZovaLocaleOptionalMap = Record<string, ZovaLocaleOptional>;