zova-core 5.0.110 → 5.0.113

package/src/bean/beanControllerBase.ts

@@ -0,0 +1,58 @@
+import { useModel } from 'vue';
+import { BeanBase } from './beanBase.js';
+import { IControllerData } from './type.js';
+import { Cast } from '../types/utils/cast.js';
+import { useRef } from '../vue/ref.js';
+
+type Data = Record<string, unknown>;
+
+type DefineModelOptions<T = any> = {
+  get?: (v: T) => any;
+  set?: (v: T) => any;
+};
+
+export interface PropsBase<Controller = unknown, Slots = unknown> {
+  controllerRef?: (ref: Controller) => void;
+  slots?: Slots;
+}
+
+export class BeanControllerBase<
+  TScopeModule = unknown,
+  Props = unknown,
+  Emits = unknown,
+  Slots = unknown,
+> extends BeanBase<TScopeModule> {
+  public $props: Props;
+  public $emit: Emits;
+  public $slots: Slots;
+  public $attrs: Data;
+
+  /** @internal */
+  public __initControllerData(controllerData: IControllerData) {
+    this.$props = controllerData.props as Props;
+    this.$emit = controllerData.context.emit as Emits;
+    this.$attrs = controllerData.context.attrs as Data;
+    this.$slots = useRef(() => {
+      const propSlots = Cast(this.$props).slots;
+      const contextSlots = controllerData.context.slots;
+      if (!propSlots) {
+        return contextSlots;
+      } else {
+        return contextSlots ? Object.assign({}, propSlots, contextSlots) : propSlots;
+      }
+    });
+    this.app.meta.module._monkeyModuleSync('controllerDataInit', undefined, controllerData, this);
+  }
+
+  // @ts-ignore ignore
+  protected $useModel(options?: DefineModelOptions<Props['modelValue']>): Props['modelValue'];
+  protected $useModel<K extends keyof Props>(name: K, options?: DefineModelOptions<Props[K]>): Props[K];
+  protected $useModel(name?, options?) {
+    if (typeof name === 'object') {
+      options = name;
+      name = 'modelValue';
+    }
+    if (!name) name = 'modelValue';
+    return useModel(this.$props as any, name, options);
+  }
+}

package/src/bean/beanControllerLike.ts

@@ -0,0 +1,29 @@
+import { Cast } from '../types/utils/cast.js';
+import { BeanBase } from './beanBase.js';
+import { BeanControllerIdentifier } from './type.js';
+
+const SymbolController = Symbol('SymbolController');
+
+export class BeanControllerLike<TScopeModule = unknown> extends BeanBase<TScopeModule> {
+  protected get [SymbolController](): unknown | undefined {
+    return this.bean._getBeanSyncOnly(BeanControllerIdentifier);
+  }
+
+  /** @internal */
+  public __get__(prop): unknown {
+    const controller = Cast(this[SymbolController]);
+    return controller?.[prop];
+  }
+
+  /** @internal */
+  public __set__(prop, value): boolean {
+    const controller = Cast(this[SymbolController]);
+    if (!controller) return false;
+    if (prop in controller) {
+      controller[prop] = value;
+      return true;
+    } else {
+      return false;
+    }
+  }
+}

package/src/bean/beanControllerPageBase.ts

@@ -0,0 +1,18 @@
+import { BeanBase } from './beanBase.js';
+import { IControllerData } from './type.js';
+
+export class BeanControllerPageBase<
+  TScopeModule = unknown,
+  Query = unknown,
+  Params = unknown,
+> extends BeanBase<TScopeModule> {
+  public $params: Params;
+  public $query: Query;
+
+  /** @internal */
+  public __initControllerData(controllerData: IControllerData) {
+    if (this.app) {
+      this.app.meta.module._monkeyModuleSync('controllerDataInit', undefined, controllerData, this);
+    }
+  }
+}

package/src/bean/beanRenderBase.ts

@@ -0,0 +1,7 @@
+import { BeanRenderLike } from './beanRenderLike.js';
+
+export class BeanRenderBase<TScopeModule = unknown> extends BeanRenderLike<TScopeModule> {
+  render() {
+    return;
+  }
+}

package/src/bean/beanRenderLike.ts

@@ -0,0 +1,33 @@
+import { Cast } from '../types/utils/cast.js';
+import { BeanControllerLike } from './beanControllerLike.js';
+import { BeanStyleIdentifier } from './type.js';
+
+const SymbolStyle = Symbol('SymbolStyle');
+
+export class BeanRenderLike<TScopeModule = unknown> extends BeanControllerLike<TScopeModule> {
+  private get [SymbolStyle](): unknown | undefined {
+    return this.bean._getBeanSyncOnly(BeanStyleIdentifier);
+  }
+
+  /** @internal */
+  public __get__(prop): unknown {
+    const value = super.__get__(prop);
+    if (value !== undefined) return value;
+    const style = Cast(this[SymbolStyle]);
+    return style?.[prop];
+  }
+
+  /** @internal */
+  public __set__(prop, value): boolean {
+    const res = super.__set__(prop, value);
+    if (res) return res;
+    const style = Cast(this[SymbolStyle]);
+    if (!style) return false;
+    if (prop in style) {
+      style[prop] = value;
+      return true;
+    } else {
+      return false;
+    }
+  }
+}

package/src/bean/beanSimple.ts

@@ -0,0 +1,11 @@
+import { ZovaApplication } from '../core/app/index.js';
+import { ZovaContext } from '../core/context/index.js';
+
+export class BeanSimple {
+  protected app: ZovaApplication;
+  protected ctx: ZovaContext;
+
+  protected get bean() {
+    return this.ctx.bean;
+  }
+}

package/src/bean/beanStyleBase.ts

@@ -0,0 +1,3 @@
+import { BeanControllerLike } from './beanControllerLike.js';
+
+export class BeanStyleBase<TScopeModule = unknown> extends BeanControllerLike<TScopeModule> {}

package/src/bean/index.ts

@@ -0,0 +1,13 @@
+export * from './resource/index.js';
+export * from './scope/index.js';
+export * from './beanBase.js';
+export * from './beanBaseSimple.js';
+export * from './beanContainer.js';
+export * from './beanControllerBase.js';
+export * from './beanControllerLike.js';
+export * from './beanControllerPageBase.js';
+export * from './beanRenderBase.js';
+export * from './beanRenderLike.js';
+export * from './beanStyleBase.js';
+export * from './beanSimple.js';
+export * from './type.js';

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

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

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

@@ -0,0 +1,5 @@
+export type TypeModuleComponents<T> = T;
+
+export interface IComponentRecord {}
+
+export interface IComponentLayoutRecord {}

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

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

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

@@ -0,0 +1,32 @@
+import { ZovaApplication } from '../../../core/app/application.js';
+
+export type TypeModuleConfig<T extends (app: ZovaApplication) => object> = ReturnType<T>;
+
+export interface IModuleConfigBroadcast {
+  bean: string | { module: string; name: string };
+}
+
+export interface IModuleConfigMiddleware {
+  bean: string | { module: string; name: string };
+  global?: boolean;
+  dependencies?: string | string[];
+}
+
+export interface IModuleConfigQueue {
+  bean: string | { module: string; name: string };
+}
+
+export interface IModuleConfigStartup {
+  bean: string | { module: string; name: string };
+  instance?: boolean;
+  debounce?: boolean;
+}
+
+export interface IModuleConfigSchedule {
+  bean: string | { module: string; name: string };
+  repeat: {
+    every?: number;
+    cron?: string;
+  };
+  disable?: boolean;
+}

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

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

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

@@ -0,0 +1 @@
+export type TypeModuleConstants<T> = T;

package/src/bean/resource/error/beanScopeError.ts

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

package/src/bean/resource/error/errorClass.ts

@@ -0,0 +1,57 @@
+import { TypeModuleResourceErrorModules } from '../../../types/interface/module.js';
+import { BeanSimple } from '../../beanSimple.js';
+import { errorsInternal } from './errorInternal.js';
+
+export class ErrorClass extends BeanSimple {
+  /** @internal */
+  public errors: TypeModuleResourceErrorModules;
+
+  /** @internal */
+  public async initialize() {
+    this.errors = {};
+  }
+
+  // code/message,args
+  throw(module, code, ...args): never {
+    const body = this.parseFail(module, code, ...args);
+    const err = new Error();
+    err.code = body.code;
+    err.message = body.message;
+    if (body.code < 500) err.status = body.code;
+    throw err;
+  }
+  // code/message,args
+  parseFail(module, code, ...args) {
+    if (typeof code === 'object') return code;
+    return this.parseCode(module, 1, code, ...args);
+  }
+  // parseCode
+  parseCode(module, codeDefault, code, ...args) {
+    const ebError = this.errors[module];
+
+    // convert from enum
+    if (code && typeof code === 'string') {
+      code = ebError[code];
+    }
+
+    if (code === undefined || code === null || code === '') {
+      code = codeDefault;
+    }
+
+    let message: string;
+    if (code <= 1000) {
+      // todo:
+      message = this.app.meta.locale.getText(undefined, undefined, errorsInternal[code], ...args);
+    } else {
+      message = this.app.meta.locale.getText(module, undefined, ebError[code], ...args);
+    }
+
+    code = __combineErrorCode(module, code);
+    return { code, message };
+  }
+}
+
+function __combineErrorCode(module, code) {
+  if (typeof code !== 'number' || code <= 1000) return code;
+  return module ? `${module}:${code}` : code;
+}

package/src/bean/resource/error/errorGlobal.ts

@@ -0,0 +1,7 @@
+declare global {
+  export interface Error {
+    code?: number | string | undefined;
+    status?: number | string | undefined;
+  }
+}
+export {};

package/src/bean/resource/error/errorInternal.ts

@@ -0,0 +1,66 @@
+export const errorsInternal = {
+  0: 'Success',
+  1: 'Unknown Error',
+  100: 'Continue',
+  101: 'Switching Protocols',
+  102: 'Processing',
+  200: 'OK',
+  201: 'Created',
+  202: 'Accepted',
+  203: 'Non-Authoritative Information',
+  204: 'No Content',
+  205: 'Reset Content',
+  206: 'Partial Content',
+  207: 'Multi-Status',
+  208: 'Already Reported',
+  226: 'IM Used',
+  300: 'Multiple Choices',
+  301: 'Moved Permanently',
+  302: 'Found',
+  303: 'See Other',
+  304: 'Not Modified',
+  305: 'Use Proxy',
+  307: 'Temporary Redirect',
+  308: 'Permanent Redirect',
+  400: 'Bad Request',
+  401: 'Unauthorized',
+  402: 'Payment Required',
+  403: 'Forbidden',
+  404: 'Not Found',
+  405: 'Method Not Allowed',
+  406: 'Not Acceptable',
+  407: 'Proxy Authentication Required',
+  408: 'Request Timeout',
+  409: 'Conflict',
+  410: 'Gone',
+  411: 'Length Required',
+  412: 'Precondition Failed',
+  413: 'Payload Too Large',
+  414: 'URI Too Long',
+  415: 'Unsupported Media Type',
+  416: 'Range Not Satisfiable',
+  417: 'Expectation Failed',
+  418: "I'm a teapot",
+  421: 'Misdirected Request',
+  422: 'Unprocessable Entity',
+  423: 'Locked',
+  424: 'Failed Dependency',
+  425: 'Unordered Collection',
+  426: 'Upgrade Required',
+  428: 'Precondition Required',
+  429: 'Too Many Requests',
+  431: 'Request Header Fields Too Large',
+  451: 'Unavailable For Legal Reasons',
+  500: 'Internal Server Error',
+  501: 'Not Implemented',
+  502: 'Bad Gateway',
+  503: 'Service Unavailable',
+  504: 'Gateway Timeout',
+  505: 'HTTP Version Not Supported',
+  506: 'Variant Also Negotiates',
+  507: 'Insufficient Storage',
+  508: 'Loop Detected',
+  509: 'Bandwidth Limit Exceeded',
+  510: 'Not Extended',
+  511: 'Network Authentication Required',
+};

package/src/bean/resource/error/errorObject.ts

@@ -0,0 +1,4 @@
+export interface IErrorObject {
+  code: number | string;
+  message: string;
+}

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

@@ -0,0 +1,6 @@
+export * from './beanScopeError.js';
+export * from './errorClass.js';
+export * from './errorGlobal.js';
+export * from './errorInternal.js';
+export * from './errorObject.js';
+export * from './type.js';

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

@@ -0,0 +1,10 @@
+import { IErrorObject } from './errorObject.js';
+
+export interface IModuleError {
+  throw(...args: any[]): never;
+  parseFail(...args: any[]): IErrorObject;
+}
+
+export type TypeModuleErrors<T> = {
+  [prop in string & keyof T]: IModuleError;
+};

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

@@ -0,0 +1,161 @@
+import { reactive } from 'vue';
+import { BeanSimple } from '../../beanSimple.js';
+import { IIconInfo, IIconMeta, TypeIconModules, TypeIconSymbols } from './types.js';
+import { IconGroup } from './iconGroup.js';
+
+const XMLNS = 'http://www.w3.org/2000/svg';
+const XMLNS_LINK = 'http://www.w3.org/1999/xlink';
+
+export class AppIcon extends BeanSimple {
+  private _iconSymbols: TypeIconSymbols = reactive({});
+  private _iconMoudles: TypeIconModules = {};
+
+  // undefined: ignore
+  // '': empty icon
+  parseIconInfoSync(iconName?: string): IIconInfo | undefined {
+    // parts
+    const meta = this.parseIconMeta(iconName);
+    if (!meta) return undefined;
+    // empty
+    const iconEmpty = { meta, symbolId: '' };
+    // check if exists
+    if (this._iconSymbols[meta.fullName] === undefined) {
+      this.parseIconInfo(iconName);
+      return iconEmpty;
+    }
+    return { meta, symbolId: meta.symbolId };
+  }
+
+  async parseIconInfo(iconName?: string): Promise<IIconInfo | undefined> {
+    // parts
+    const meta = this.parseIconMeta(iconName);
+    if (!meta) return undefined;
+    // check if exists
+    if (this._iconSymbols[meta.fullName]) {
+      return { meta, symbolId: this._iconSymbols[meta.fullName] };
+    }
+    // pre set
+    this._iconSymbols[meta.fullName] = '';
+    // icon group
+    const iconGroup = await this.parseIconGroup(meta.module, meta.group);
+    if (!iconGroup) return undefined;
+    // icon inject
+    const symbolId = this._injectIcon(meta);
+    this._iconSymbols[meta.fullName] = symbolId;
+    // ok
+    return { meta, symbolId };
+  }
+
+  public async parseIconGroup(moduleName: string, groupName: string): Promise<string | undefined> {
+    // check if exists
+    const iconModule = this._getIconModule(moduleName);
+    if (iconModule[groupName]) {
+      await iconModule[groupName].loaded.wait();
+      return iconModule[groupName].svg;
+    }
+    // record
+    iconModule[groupName] = new IconGroup();
+    // parse
+    const svg = await this._parseIconGroupInner(moduleName, groupName);
+    // touch
+    iconModule[groupName].svg = svg;
+    iconModule[groupName].loaded.touch();
+    // ok
+    return iconModule[groupName].svg;
+  }
+
+  private async _parseIconGroupInner(moduleName: string, groupName: string): Promise<string | undefined> {
+    // module
+    const module = await this.app.meta.module.use(moduleName);
+    if (!module) return;
+    // icons
+    const icons = module.resource.icons;
+    const groupUrl = icons[groupName];
+    if (!groupUrl) return;
+    // fetch
+    const res = await fetch(groupUrl);
+    if (!res.ok) return;
+    const svg = await res.text();
+    return svg;
+  }
+
+  private _injectIcon(meta: IIconMeta) {
+    const iconModule = this._getIconModule(meta.module);
+    const iconGroup = iconModule[meta.group];
+    // inject container
+    let domContainer = document.getElementById('zova-svg-container');
+    if (!domContainer) {
+      domContainer = document.createElement('div');
+      domContainer.style.position = 'absolute';
+      domContainer.style.width = '0';
+      domContainer.style.height = '0';
+      domContainer.style.display = 'none';
+      domContainer.id = 'zova-svg-container';
+      document.body.appendChild(domContainer);
+    }
+    // inject module
+    let domModule = document.getElementById(`zova-svg-module-${meta.module}`);
+    if (!domModule) {
+      domModule = document.createElement('div');
+      domModule.id = `zova-svg-module-${meta.module}`;
+      domContainer.appendChild(domModule);
+    }
+    // inject group
+    let domGroup = document.getElementById(`zova-svg-group-${meta.module}-${meta.group}`) as unknown as SVGSVGElement;
+    if (!domGroup) {
+      domGroup = document.createElementNS(XMLNS, 'svg');
+      domGroup.id = `zova-svg-group-${meta.module}-${meta.group}`;
+      domGroup.setAttribute('xmlns', XMLNS);
+      domGroup.setAttribute('xmlns:link', XMLNS_LINK);
+      domModule.appendChild(domGroup);
+    }
+    // inject icon
+    const domIcon = document.getElementById(meta.symbolId) as unknown as SVGElement;
+    if (!domIcon) {
+      const symbolPattern = new RegExp(`<symbol.*?id="${meta.symbolId}".*?>.*?</symbol>`);
+      const matched = symbolPattern.exec(iconGroup.svg || '');
+      if (matched) {
+        domGroup.insertAdjacentHTML('beforeend', matched[0]);
+      }
+    }
+    // ok
+    return meta.symbolId;
+  }
+
+  private _getIconModule(moduleName: string) {
+    if (!this._iconMoudles[moduleName]) {
+      this._iconMoudles[moduleName] = {};
+    }
+    return this._iconMoudles[moduleName];
+  }
+
+  parseIconMeta(iconName?: string): IIconMeta | undefined {
+    if (!iconName) return;
+    // split module:group:name
+    const parts = iconName.split(':');
+    if (parts.length !== 3) {
+      return;
+    }
+    const module = parts[0] || this.app.config.icon.defaultModule;
+    const group = parts[1] || 'default';
+    const name = parts[2] || '';
+    if (module.indexOf('-') === -1 || !name) {
+      return;
+    }
+    return {
+      module,
+      group,
+      name,
+      fullName: this._getFullName(module, group, name),
+      symbolId: this._getSymbolId(module, group, name),
+    };
+  }
+
+  private _getSymbolId(module: string, group: string, name: string) {
+    return `zova-svg-icon-${module}-${group}-${name}`;
+  }
+
+  private _getFullName(module: string, group: string, name: string) {
+    return `${module}:${group}:${name}`;
+  }
+}

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

@@ -0,0 +1,10 @@
+import { StateLock } from '../../../utils/stateLock.js';
+
+export class IconGroup {
+  public svg: string | undefined;
+  public loaded: StateLock;
+
+  constructor() {
+    this.loaded = StateLock.create();
+  }
+}

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

@@ -0,0 +1,4 @@
+export * from './zovaIcon.js';
+export * from './types.js';
+export * from './useZovaIcon.js';
+export * from './utils.js';

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

@@ -0,0 +1,21 @@
+import { IconGroup } from './iconGroup.js';
+
+export interface IIconRecord {}
+export type TypeIcon = keyof IIconRecord;
+
+export interface IIconMeta {
+  module: string;
+  group: string;
+  name: string;
+  fullName: string;
+  symbolId: string;
+}
+
+export interface IIconInfo {
+  meta: IIconMeta;
+  symbolId: string; // '' or valid icon
+}
+
+export type TypeIconGroups = Record<string, IconGroup>;
+export type TypeIconModules = Record<string, TypeIconGroups>;
+export type TypeIconSymbols = Record<string, string>;

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

@@ -0,0 +1,20 @@
+import { ref, watchEffect } from 'vue';
+import { useApp } from '../../../composables/useApp.js';
+import { ZovaApplication } from '../../../core/index.js';
+import { IIconInfo } from './types.js';
+
+export function getZovaIcon(iconName?: string, app?: ZovaApplication): IIconInfo | undefined {
+  if (!app) app = useApp();
+  return app.meta.icon.parseIconInfoSync(iconName);
+}
+
+export function useZovaIcon(iconGetter: () => string | undefined) {
+  const iconInfo = ref<IIconInfo>();
+  const app = useApp();
+
+  watchEffect(() => {
+    iconInfo.value = getZovaIcon(iconGetter(), app);
+  });
+
+  return { iconInfo };
+}

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

@@ -0,0 +1,20 @@
+import { createVNode, VNode } from 'vue';
+import { IIconRecord } from './types.js';
+import { ZovaIcon } from './zovaIcon.js';
+
+// should not provide name?: string
+//export function iconh(name?: string, color?: string, size?: string | number);
+export function iconh<K extends keyof IIconRecord>(name: K, color?: string, size?: string | number): VNode;
+export function iconh(name?, color?, size?): VNode {
+  size = size ?? 24;
+  return createVNode(ZovaIcon, {
+    name,
+    color,
+    width: size,
+    height: size,
+  });
+}
+
+export function icon<K extends keyof IIconRecord>(name: K): K {
+  return name;
+}