zova-core 5.0.110 → 5.0.113

package/src/decorator/interface/beanOptions.ts

@@ -0,0 +1,80 @@
+import { MetadataKey } from '../../core/metadata.js';
+import { Constructable } from '../index.js';
+import { ContainerScope } from '../index.js';
+
+export type TypeDecoratorBeanOptionsSceneBase = 'local' | 'aop' | 'virtual' | 'scope' | TypeDecoratorBeanOptionsScene;
+// containerScope: store(app) model(ctx)
+export type TypeDecoratorBeanOptionsScene = 'bean' | 'store' | 'model' | 'style' | 'theme' | 'tool'; // | 'ui' | 'event';
+
+export interface IDecoratorBeanOptionsBase<T = unknown> {
+  /**
+   * global: module.scene.name
+   * others: undefined: use beanClass
+   */
+  beanFullName: string;
+  beanUuid: string;
+  module: string;
+  scene?: TypeDecoratorBeanOptionsSceneBase;
+  name: string;
+  beanClass: Constructable<T>;
+  containerScope?: ContainerScope;
+  markReactive?: boolean;
+  aop?: boolean;
+  aopMatch?: string | RegExp | (string | RegExp)[];
+  virtual?: boolean;
+  moduleBelong?: string;
+  options?: unknown;
+  __aopChains__: MetadataKey[];
+  __aopChainsKey__: Record<string, [MetadataKey, string][]>;
+}
+
+export interface IDecoratorBeanOptions {
+  scene?: TypeDecoratorBeanOptionsScene;
+  name?: string;
+  containerScope?: ContainerScope;
+  markReactive?: boolean;
+}
+
+export type IDecoratorVirtualOptions = IDecoratorBeanOptions;
+
+export interface IDecoratorLocalOptions {
+  containerScope?: ContainerScope;
+  markReactive?: boolean;
+}
+
+export interface IDecoratorAopOptions {
+  name?: string;
+  match: string | RegExp | (string | RegExp)[];
+}
+
+export interface IDecoratorScopeOptions {}
+
+export interface IDecoratorStoreOptions {
+  scene?: TypeDecoratorBeanOptionsScene;
+  name?: string;
+  markReactive?: boolean;
+}
+
+export interface IDecoratorModelOptions {
+  scene?: TypeDecoratorBeanOptionsScene;
+  name?: string;
+  markReactive?: boolean;
+}
+
+export interface IDecoratorStyleOptions {
+  scene?: TypeDecoratorBeanOptionsScene;
+  name?: string;
+  markReactive?: boolean;
+}
+
+export interface IDecoratorThemeOptions {
+  scene?: TypeDecoratorBeanOptionsScene;
+  name?: string;
+  markReactive?: boolean;
+}
+
+export interface IDecoratorToolOptions {
+  scene?: TypeDecoratorBeanOptionsScene;
+  name?: string;
+  markReactive?: boolean;
+}

package/src/decorator/interface/useOptions.ts

@@ -0,0 +1,37 @@
+import { IBeanRecord, IBeanScopeRecord } from '../../bean/type.js';
+import { MetadataKey } from '../../core/metadata.js';
+import { Constructable } from '../type/constructable.js';
+import { InjectionScope } from '../type/injectionScope.js';
+import { Functionable } from '../type/functionable.js';
+
+export interface IDecoratorUseOptionsBase<T = unknown> {
+  prop: MetadataKey;
+  beanFullName?: string;
+  name?: string;
+  beanClass?: Constructable<T>;
+  beanComposable?: Functionable;
+  /** such as: moduleScope */
+  selector?: string;
+  injectionScope?: InjectionScope;
+  markReactive?: boolean;
+}
+
+export interface IDecoratorUseOptions {
+  beanFullName?: keyof IBeanRecord;
+  name?: string;
+  selector?: string;
+  injectionScope?: InjectionScope;
+  markReactive?: boolean;
+}
+
+export interface IDecoratorUseComposableOptions {
+  beanComposable?: Functionable;
+  name?: string;
+  selector?: string;
+  injectionScope?: InjectionScope;
+  markReactive?: boolean;
+}
+
+export interface IDecoratorUseScopeOptions {
+  module: keyof IBeanScopeRecord;
+}

package/src/decorator/type/constructable.ts

@@ -0,0 +1 @@
+export type Constructable<T = unknown> = new (...args: any[]) => T;

package/src/decorator/type/containerScope.ts

@@ -0,0 +1 @@
+export type ContainerScope = 'app' | 'ctx' | 'new';

package/src/decorator/type/functionable.ts

@@ -0,0 +1 @@
+export type Functionable<T = unknown> = (...args: any[]) => T;

package/src/decorator/type/injectionScope.ts

@@ -0,0 +1 @@
+export type InjectionScope = 'app' | 'ctx' | 'new' | 'host' | 'skipSelf';

package/src/index.ts

@@ -0,0 +1,9 @@
+export * from './bean/index.js';
+export * from './core/index.js';
+export * from './decorator/index.js';
+export * from './composables/index.js';
+export * from './plugins/index.js';
+export * from './types/index.js';
+export * from './utils/index.js';
+export * from './vue/index.js';
+export * from './zod/index.js';

package/src/plugins/bean.ts

@@ -0,0 +1,16 @@
+import { App } from 'vue';
+import { ZovaContext } from '../core/index.js';
+
+export const PluginBean = {
+  install(app: App) {
+    app.mixin({
+      created() {
+        // this._ is instance, not use self.$
+        const ctx: ZovaContext = this._.zova;
+        if (ctx) {
+          ctx.meta.component.activate();
+        }
+      },
+    });
+  },
+};

package/src/plugins/index.ts

@@ -0,0 +1,2 @@
+export * from './bean.js';
+export * from './zova.js';

package/src/plugins/zova.ts

@@ -0,0 +1,28 @@
+import { App } from 'vue';
+import { ZovaApplication, ZovaContext } from '../core/index.js';
+import { PluginZovaOptions } from '../types/interface/pluginZova.js';
+import { BeanContainerInstances } from '../bean/beanContainer.js';
+import { Cast } from '../types/index.js';
+import { BeanControllerIdentifier, BeanRenderIdentifier, BeanStyleIdentifier } from '../bean/type.js';
+
+export const PluginZova = {
+  async install(vue: App, ctxRoot: ZovaContext, { modulesMeta, AppMonkey, locales, config }: PluginZovaOptions) {
+    // zova app
+    const app = new ZovaApplication(vue, ctxRoot);
+    await app.initialize({ modulesMeta, AppMonkey, locales, config });
+    return app;
+  },
+  async update(app: ZovaApplication, ctxRoot: ZovaContext) {
+    const bean = Cast(app.bean);
+    bean.ctx = ctxRoot;
+    for (const key in bean[BeanContainerInstances]) {
+      bean[BeanContainerInstances][key].ctx = ctxRoot;
+    }
+    delete bean[BeanContainerInstances][BeanControllerIdentifier];
+    delete bean[BeanContainerInstances][BeanRenderIdentifier];
+    delete bean[BeanContainerInstances][BeanStyleIdentifier];
+    Object.assign(bean[BeanContainerInstances], ctxRoot.bean[BeanContainerInstances]);
+    ctxRoot.bean = bean;
+    ctxRoot.app = app;
+  },
+};

package/src/types/index.ts

@@ -0,0 +1,2 @@
+export * from './interface/index.js';
+export * from './utils/index.js';

package/src/types/interface/component.ts

@@ -0,0 +1,36 @@
+import 'vue';
+import 'vue/jsx-runtime';
+import '@vue/runtime-dom';
+
+declare module 'vue' {
+  export interface ComponentCustomOptions {
+    meta?: {
+      global?: boolean;
+    };
+  }
+
+  export interface AllowedComponentProps {}
+}
+
+declare module 'vue/jsx-runtime' {
+  namespace JSX {
+    // need define class/style in IntrinsicAttributes
+    export interface IntrinsicAttributes {
+      class?: unknown;
+      style?: unknown;
+      onClick?: (e: MouseEvent) => void;
+    }
+  }
+}
+
+declare module '@vue/runtime-dom' {
+  export interface LabelHTMLAttributes {
+    htmlFor?: string;
+  }
+
+  export interface SVGAttributes {
+    strokeLinecap?: string;
+    strokeLinejoin?: string;
+    strokeWidth?: string;
+  }
+}

package/src/types/interface/event.ts

@@ -0,0 +1,28 @@
+export type TypeEventOff = () => void;
+
+export type TypeEventHandlersMap<KS extends keyof IEventRecord> = {
+  [K in KS]: TypeEventHandlers<IEventRecord[K], IEventResultRecord[K]>;
+};
+
+export type TypeEventHandlers<D = unknown, R = unknown> = TypeEventHandlerWrapper<D, R>[];
+
+export type TypeEventContext<D, R> = {
+  data: D;
+  result: R;
+};
+
+export type TypeEventHandlerWrapper<D, R> = {
+  fn: TypeEventHandler<D, R> | null;
+};
+
+export type TypeEventHandler<D, R> = {
+  (context: TypeEventContext<D, R>, next: TypeEventNext): Promise<void>;
+};
+
+export type TypeEventNext = () => Promise<void>;
+
+export interface IEventRecord {}
+export type TypeEventRecordKeys = keyof IEventRecord;
+
+export interface IEventResultRecord {}
+export type TypeEventResultRecordKeys = keyof IEventResultRecord;

package/src/types/interface/index.ts

@@ -0,0 +1,6 @@
+export * from './component.js';
+export * from './event.js';
+export * from './inject.js';
+export * from './module.js';
+export * from './monkey.js';
+export * from './pluginZova.js';

package/src/types/interface/inject.ts

@@ -0,0 +1,2 @@
+export interface IInjectRecord {}
+export type TypeInjectRecordKeys = keyof IInjectRecord;

package/src/types/interface/module.ts

@@ -0,0 +1,38 @@
+import { IModuleInfo } from '@cabloy/module-info';
+import { ZovaApplication } from '../../core/app/application.js';
+import { IModuleMain, IMonkeyModule, IMonkeyController, IMonkeySystem } from './monkey.js';
+import { StateLock } from '../../utils/stateLock.js';
+import { Component } from 'vue';
+
+export type TypeModuleResourceIcons = Record<string, string>;
+export type TypeModuleResourceLocales = Record<string, object>;
+export type TypeModuleResourceLocaleModules = Record<string, TypeModuleResourceLocales>;
+export type TypeModuleResourceErrors = Record<number, string>;
+export type TypeModuleResourceErrorModules = Record<string, TypeModuleResourceErrors>;
+export type TypeModuleResourceComponents = Record<string, Component>;
+export type TypeModuleResourceServices = Record<string, (app: ZovaApplication) => object>;
+
+export interface IModuleResource {
+  Main: new () => IModuleMain;
+  Monkey: new () => IMonkeyModule & IMonkeySystem & IMonkeyController;
+  locales: TypeModuleResourceLocales;
+  Errors: TypeModuleResourceErrors;
+  config: (app: ZovaApplication) => object | Promise<object>;
+  constants: unknown;
+  icons: TypeModuleResourceIcons;
+  components: TypeModuleResourceComponents;
+  services: TypeModuleResourceServices;
+}
+
+export const SymbolInstalled = Symbol('SymbolInstalled');
+
+declare module '@cabloy/module-info' {
+  export interface IModule {
+    /** @internal */
+    [SymbolInstalled]: StateLock;
+    resource: IModuleResource; // IModuleResource | Promise<IModuleResource>;
+    info: IModuleInfo;
+    mainInstance: IModuleMain;
+    monkeyInstance: IMonkeyModule & IMonkeySystem & IMonkeyController;
+  }
+}

package/src/types/interface/monkey.ts

@@ -0,0 +1,38 @@
+import { IModule } from '@cabloy/module-info';
+import { BeanBase } from '../../bean/beanBase.js';
+import { BeanContainer } from '../../bean/beanContainer.js';
+import { IControllerData } from '../../bean/type.js';
+
+export type TypeMonkeyName = keyof IMonkeyModule | keyof IMonkeySystem | keyof IMonkeyController;
+
+export interface IMonkeyApp {
+  moduleLoading(module: IModule): Promise<void>;
+  moduleLoaded(module: IModule): Promise<void>;
+  configLoaded(module: IModule, config: any): Promise<void>;
+}
+
+export interface IModuleMain {
+  moduleLoading(): Promise<void>;
+  moduleLoaded(): Promise<void>;
+  configLoaded(config: any): Promise<void>;
+}
+
+export interface IMonkeyModule {
+  moduleLoading(module: IModule): Promise<void>;
+  moduleLoaded(module: IModule): Promise<void>;
+  configLoaded(module: IModule, config: any): Promise<void>;
+}
+
+export interface IMonkeySystem {
+  appInitialize(bean: BeanContainer): Promise<void>;
+  appInitialized(bean: BeanContainer): Promise<void>;
+  beanInit(bean: BeanContainer, beanInstance: BeanBase): Promise<void>;
+  beanInited(bean: BeanContainer, beanInstance: BeanBase): Promise<void>;
+  beanDispose(bean: BeanContainer, beanInstance: BeanBase): void;
+  beanDisposed(bean: BeanContainer, beanInstance: BeanBase): void;
+}
+
+export interface IMonkeyController {
+  controllerDataPrepare(controllerData: IControllerData);
+  controllerDataInit(controllerData: IControllerData, controller: BeanBase);
+}

package/src/types/interface/pluginZova.ts

@@ -0,0 +1,17 @@
+import { IModule } from '@cabloy/module-info';
+import { ZovaConfig } from '../../core/app/config.js';
+import { IMonkeyApp, IMonkeySystem, IMonkeyController } from './monkey.js';
+import { Constructable } from '../../decorator/index.js';
+import { ZovaLocaleOptionalMap } from '../../core/app/locale.js';
+
+export interface PluginZovaModulesMeta {
+  modules: Record<string, IModule>;
+  moduleNames: string[];
+}
+
+export interface PluginZovaOptions {
+  modulesMeta: PluginZovaModulesMeta;
+  AppMonkey: Constructable<IMonkeyApp & IMonkeySystem & IMonkeyController>;
+  locales: ZovaLocaleOptionalMap;
+  config: ZovaConfig;
+}

package/src/types/utils/cast.ts

@@ -0,0 +1,8 @@
+export function Cast<T = any>(source: unknown) {
+  return source as T;
+}
+
+declare global {
+  function parseInt(num: number, radix?: number): number;
+  function parseInt(num: any, radix?: number): number;
+}

package/src/types/utils/env.ts

@@ -0,0 +1,35 @@
+export interface ZovaConfigMeta {
+  flavor: 'app' | 'web' | string;
+  mode: 'development' | 'production' | string;
+  appMode: 'spa' | 'ssr' | 'pwa' | 'cordova' | 'capacitor' | 'electron' | 'bex' | string | undefined;
+}
+
+export interface ZovaConfigEnv {
+  appServer: boolean;
+  appRouterMode: 'hash' | 'history' | 'abstract' | undefined;
+  appRouterBase: string | undefined;
+  appPublicPath: string | undefined;
+  appName: string | undefined;
+  appTitle: string | undefined;
+  appVersion: string | undefined;
+}
+
+declare global {
+  namespace NodeJS {
+    interface ProcessEnv {
+      NODE_ENV: 'development' | 'production';
+      META_FLAVOR: 'app' | 'web' | string;
+      META_MODE: 'development' | 'production';
+      META_APP_MODE: 'spa' | 'ssr' | 'pwa' | 'cordova' | 'capacitor' | 'electron' | 'bex' | string | undefined;
+      APP_SERVER: string | undefined;
+      APP_ROUTER_MODE: 'hash' | 'history' | 'abstract' | undefined;
+      APP_ROUTER_BASE: string | undefined;
+      APP_PUBLIC_PATH: string | undefined;
+      APP_NAME: string | undefined;
+      APP_TITLE: string | undefined;
+      APP_VERSION: string | undefined;
+      DEV_SERVER_HOST: string | undefined;
+      DEV_SERVER_PORT: string | undefined;
+    }
+  }
+}

package/src/types/utils/index.ts

@@ -0,0 +1,3 @@
+export * from './cast.js';
+export * from './env.js';
+export * from './powerPartial.js';

package/src/types/utils/powerPartial.ts

@@ -0,0 +1,3 @@
+export type PowerPartial<T> = {
+  [U in keyof T]?: T[U] extends object ? PowerPartial<T[U]> : T[U];
+};

package/src/utils/index.ts

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

package/src/utils/isClass.ts

@@ -0,0 +1,17 @@
+export function isClass(fn) {
+  // just check if is function
+  return typeof fn === 'function';
+}
+
+// function fnBody(fn) {
+//   return toString
+//     .call(fn)
+//     .replace(/^[^{]*{\s*/, '')
+//     .replace(/\s*}[^}]*$/, '');
+// }
+
+// export function isClass(fn) {
+//   return (
+//     typeof fn === 'function' && (/^class(?:\s|{)/.test(toString.call(fn)) || /^.*classCallCheck\(/.test(fnBody(fn))) // babel.js
+//   );
+// }

package/src/utils/stateLock.ts

@@ -0,0 +1,47 @@
+import { reactive, watch } from 'vue';
+
+// eslint-disable-next-line
+let __counter = 0;
+
+export class StateLock {
+  private _state: boolean;
+
+  static create() {
+    return reactive(new StateLock()) as StateLock;
+  }
+
+  protected constructor() {
+    this._state = false;
+    __counter++;
+  }
+
+  get state() {
+    return this._state;
+  }
+
+  set state(value) {
+    if (this._state !== value) {
+      this._state = value;
+      __counter--;
+      // console.log('-----lock counter: ', __counter);
+    }
+  }
+
+  touch() {
+    this.state = true;
+  }
+
+  async wait() {
+    return new Promise(resolve => {
+      // condition check should place in the promise inner
+      if (this.state) return resolve(null);
+      watch(
+        () => this.state,
+        () => {
+          resolve(null);
+        },
+        { once: true },
+      );
+    });
+  }
+}

package/src/utils/uuid.ts

@@ -0,0 +1,84 @@
+/**
+ * Based on the work of https://github.com/jchook/uuid-random
+ */
+
+let buf,
+  bufIdx = 0;
+const hexBytes = new Array(256);
+
+// Pre-calculate toString(16) for speed
+for (let i = 0; i < 256; i++) {
+  hexBytes[i] = (i + 0x100).toString(16).substring(1);
+}
+
+// Use best available PRNG
+const randomBytes = (() => {
+  // Node & Browser support
+  const lib: any =
+    typeof crypto !== 'undefined'
+      ? crypto
+      : typeof window !== 'undefined'
+        ? window.crypto || (<any>window).msCrypto
+        : void 0;
+
+  if (lib !== void 0) {
+    if (lib.randomBytes !== void 0) {
+      return lib.randomBytes;
+    }
+    if (lib.getRandomValues !== void 0) {
+      return n => {
+        const bytes = new Uint8Array(n);
+        lib.getRandomValues(bytes);
+        return bytes;
+      };
+    }
+  }
+
+  return n => {
+    const r: number[] = [];
+    for (let i = n; i > 0; i--) {
+      r.push(Math.floor(Math.random() * 256));
+    }
+    return r;
+  };
+})();
+
+// Buffer random numbers for speed
+// Reduce memory usage by decreasing this number (min 16)
+// or improve speed by increasing this number (try 16384)
+const BUFFER_SIZE = 4096;
+
+export function uuid() {
+  // Buffer some random bytes for speed
+  if (buf === void 0 || bufIdx + 16 > BUFFER_SIZE) {
+    bufIdx = 0;
+    buf = randomBytes(BUFFER_SIZE);
+  }
+
+  const b = Array.prototype.slice.call(buf, bufIdx, (bufIdx += 16));
+  b[6] = (b[6] & 0x0f) | 0x40;
+  b[8] = (b[8] & 0x3f) | 0x80;
+
+  return (
+    hexBytes[b[0]] +
+    hexBytes[b[1]] +
+    hexBytes[b[2]] +
+    hexBytes[b[3]] +
+    '-' +
+    hexBytes[b[4]] +
+    hexBytes[b[5]] +
+    '-' +
+    hexBytes[b[6]] +
+    hexBytes[b[7]] +
+    '-' +
+    hexBytes[b[8]] +
+    hexBytes[b[9]] +
+    '-' +
+    hexBytes[b[10]] +
+    hexBytes[b[11]] +
+    hexBytes[b[12]] +
+    hexBytes[b[13]] +
+    hexBytes[b[14]] +
+    hexBytes[b[15]]
+  );
+}

package/src/vue/composable.ts

@@ -0,0 +1,10 @@
+import { UnwrapNestedRefs } from 'vue';
+import { Functionable } from '../decorator/type/functionable.js';
+
+export type ReturnTypeComposable<Composable extends Functionable> = Composable extends (...args: any[]) => infer R
+  ? UnwrapNestedRefs<R>
+  : any;
+
+export function useComposable<T extends Functionable>(composable: T, ...args: Parameters<T>): ReturnTypeComposable<T> {
+  return composable(...args) as ReturnTypeComposable<T>;
+}

package/src/vue/computed.ts

@@ -0,0 +1,7 @@
+import { computed, ComputedGetter, DebuggerOptions, WritableComputedOptions } from 'vue';
+
+export function useComputed<T>(getter: ComputedGetter<T>, debugOptions?: DebuggerOptions): T;
+export function useComputed<T>(options: WritableComputedOptions<T>, debugOptions?: DebuggerOptions): T;
+export function useComputed(options, debugOptions) {
+  return computed(options, debugOptions);
+}

package/src/vue/customRef.ts

@@ -0,0 +1,5 @@
+import { CustomRefFactory, customRef } from 'vue';
+
+export function useCustomRef<T>(factory: CustomRefFactory<T>): T {
+  return customRef(factory) as T;
+}

package/src/vue/index.ts

@@ -0,0 +1,4 @@
+export * from './composable.js';
+export * from './computed.js';
+export * from './customRef.js';
+export * from './ref.js';

package/src/vue/ref.ts

@@ -0,0 +1,12 @@
+import { Ref, UnwrapRef, toRef } from 'vue';
+
+export function useRef<T>(value: T): T extends () => infer R ? R : T extends Ref ? UnwrapRef<T> : UnwrapRef<T>;
+export function useRef<T extends object, K extends keyof T>(object: T, key: K): T[K];
+export function useRef<T extends object, K extends keyof T>(
+  object: T,
+  key: K,
+  defaultValue: T[K],
+): Exclude<T[K], undefined>;
+export function useRef(object, key?, defaultValue?) {
+  return toRef(object, key, defaultValue);
+}

package/src/zod/index.ts

@@ -0,0 +1,2 @@
+export { z } from 'zod';
+export * as zz from './zz.js';