vona-core 1.0.0 → 5.0.9

package/dist/lib/bean/resource/error/_errorInternal.d.ts

@@ -0,0 +1,66 @@
+export declare const errorsInternal: {
+    0: string;
+    1: string;
+    100: string;
+    101: string;
+    102: string;
+    200: string;
+    201: string;
+    202: string;
+    203: string;
+    204: string;
+    205: string;
+    206: string;
+    207: string;
+    208: string;
+    226: string;
+    300: string;
+    301: string;
+    302: string;
+    303: string;
+    304: string;
+    305: string;
+    307: string;
+    308: string;
+    400: string;
+    401: string;
+    402: string;
+    403: string;
+    404: string;
+    405: string;
+    406: string;
+    407: string;
+    408: string;
+    409: string;
+    410: string;
+    411: string;
+    412: string;
+    413: string;
+    414: string;
+    415: string;
+    416: string;
+    417: string;
+    418: string;
+    421: string;
+    422: string;
+    423: string;
+    424: string;
+    425: string;
+    426: string;
+    428: string;
+    429: string;
+    431: string;
+    451: string;
+    500: string;
+    501: string;
+    502: string;
+    503: string;
+    504: string;
+    505: string;
+    506: string;
+    507: string;
+    508: string;
+    509: string;
+    510: string;
+    511: string;
+};

package/dist/lib/bean/resource/error/_errorInternal.js

@@ -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/dist/lib/bean/resource/error/beanScopeError.d.ts

@@ -0,0 +1,10 @@
+import type { IModuleError } from './type.ts';
+import { BeanSimple } from '../../beanSimple.ts';
+declare const BeanModuleScope: unique symbol;
+export declare class BeanScopeError extends BeanSimple {
+    private [BeanModuleScope];
+    private __instances;
+    constructor(moduleScope: any);
+    protected __get__(prop: string): IModuleError;
+}
+export {};

package/dist/lib/bean/resource/error/beanScopeError.js

@@ -0,0 +1,17 @@
+import { BeanSimple } from "../../beanSimple.js";
+import { BeanScopeErrorImpl } from "./beanScopeErrorImpl.js";
+const BeanModuleScope = Symbol('BeanScopeError#ModuleScope');
+export class BeanScopeError extends BeanSimple {
+    [BeanModuleScope];
+    __instances = {};
+    constructor(moduleScope) {
+        super();
+        this[BeanModuleScope] = moduleScope;
+    }
+    __get__(prop) {
+        if (!this.__instances[prop]) {
+            this.__instances[prop] = this.bean._newBean(BeanScopeErrorImpl, this[BeanModuleScope], prop);
+        }
+        return this.__instances[prop];
+    }
+}

package/dist/lib/bean/resource/error/beanScopeErrorImpl.d.ts

@@ -0,0 +1,13 @@
+import type { IErrorObject } from './errorObject.ts';
+import type { IModuleError } from './type.ts';
+import { BeanSimple } from '../../beanSimple.ts';
+declare const BeanModuleScope: unique symbol;
+declare const BeanErrorCode: unique symbol;
+export declare class BeanScopeErrorImpl extends BeanSimple implements IModuleError {
+    private [BeanModuleScope];
+    private [BeanErrorCode];
+    constructor(moduleScope: any, errorCode: any);
+    throw(...args: any[]): never;
+    parseFail(...args: any[]): IErrorObject;
+}
+export {};

package/dist/lib/bean/resource/error/beanScopeErrorImpl.js

@@ -0,0 +1,18 @@
+import { BeanSimple } from "../../beanSimple.js";
+const BeanModuleScope = Symbol('BeanScopeError#ModuleScope');
+const BeanErrorCode = Symbol('BeanScopeError#BeanErrorCode');
+export class BeanScopeErrorImpl extends BeanSimple {
+    [BeanModuleScope];
+    [BeanErrorCode];
+    constructor(moduleScope, errorCode) {
+        super();
+        this[BeanModuleScope] = moduleScope;
+        this[BeanErrorCode] = errorCode;
+    }
+    throw(...args) {
+        return this.app.meta.error.throw(this[BeanModuleScope], this[BeanErrorCode], ...args);
+    }
+    parseFail(...args) {
+        return this.app.meta.error.parseFail(this[BeanModuleScope], this[BeanErrorCode], ...args);
+    }
+}

package/dist/lib/bean/resource/error/errorApplication.d.ts

@@ -0,0 +1,32 @@
+import type { HttpStatus } from '../../../../types/index.ts';
+import type { IErrorObject } from './errorObject.ts';
+type TypeErrorMethodNames = 'parseFail' | 'parseSuccess';
+interface TypeErrorMethodCommon {
+    (code: number | string, ...args: any[]): IErrorObject;
+}
+interface TypeErrorMethodFail {
+    (code: number | string, ...args: any[]): void;
+}
+interface TypeErrorMethodThrow {
+    (code: HttpStatus | number | string, ...args: any[]): never;
+}
+interface TypeErrorMethodSuccess {
+    (data?: any, ...args: any[]): void;
+}
+interface TypeErrorMethodParseCode {
+    (codeDefault: number, code: number | string, ...args: any[]): IErrorObject;
+}
+type TypeErrorMethods = {
+    success: TypeErrorMethodSuccess;
+} & {
+    throw: TypeErrorMethodThrow;
+} & {
+    fail: TypeErrorMethodFail;
+} & {
+    [property in TypeErrorMethodNames]: TypeErrorMethodCommon;
+} & {
+    parseCode: TypeErrorMethodParseCode;
+};
+export interface ApplicationError extends TypeErrorMethods {
+}
+export {};

package/dist/lib/bean/resource/error/errorApplication.js

@@ -0,0 +1 @@
+export {};

package/dist/lib/bean/resource/error/errorClass.d.ts

@@ -0,0 +1,17 @@
+import { BeanSimple } from '../../beanSimple.ts';
+export declare class ErrorClass extends BeanSimple {
+    ebErrors: any;
+    constructor(ebErrors: any);
+    success(module: any, data: any, code: any, ...args: any[]): void;
+    fail(module: any, code: any, ...args: any[]): void;
+    throw(module: any, code: any, ...args: any[]): never;
+    parseFail(module: any, code: any, ...args: any[]): any;
+    parseSuccess(module: any, code: any, ...args: any[]): {
+        code: any;
+        message: string;
+    };
+    parseCode(module: any, codeDefault: any, code: any, ...args: any[]): {
+        code: any;
+        message: string;
+    };
+}

package/dist/lib/bean/resource/error/errorClass.js

@@ -0,0 +1,71 @@
+import { HttpStatus } from "../../../../types/enum/httpStatus.js";
+import { BeanSimple } from "../../beanSimple.js";
+export class ErrorClass extends BeanSimple {
+    ebErrors;
+    constructor(ebErrors) {
+        super();
+        this.ebErrors = ebErrors;
+    }
+    // data,code/message,args
+    success(module, data, code, ...args) {
+        const body = this.parseSuccess(module, code, ...args);
+        this.ctx.response.status = 200;
+        this.ctx.response.type = 'application/json';
+        this.ctx.response.body = { code: 0, message: body.message, data };
+    }
+    // code/message,args
+    fail(module, code, ...args) {
+        const body = this.parseFail(module, code, ...args);
+        this.ctx.response.status = __calcStatus(body.code);
+        this.ctx.response.type = 'application/json';
+        this.ctx.response.body = { code: body.code, message: body.message }; // body maybe Error
+    }
+    // code/message,args
+    throw(module, code, ...args) {
+        const body = this.parseFail(module, code, ...args);
+        const err = new Error();
+        err.code = body.code;
+        err.message = body.message;
+        err.status = __calcStatus(body.code);
+        throw err;
+    }
+    // code/message,args
+    parseFail(module, code, ...args) {
+        if (typeof code === 'object')
+            return code;
+        return this.parseCode(module, 500, code, ...args);
+    }
+    // code/message,args
+    parseSuccess(module, code, ...args) {
+        return this.parseCode(module, 0, code, ...args);
+    }
+    // parseCode
+    parseCode(module, codeDefault, code, ...args) {
+        const ebError = this.ebErrors[module];
+        // convert from enum
+        if (ebError && code && typeof code === 'string') {
+            code = ebError[code];
+        }
+        if (code === undefined || code === null || code === '') {
+            code = codeDefault;
+        }
+        let message;
+        if (typeof code === 'number' && code <= 1000) {
+            const httpStatusMessageKey = `HTTPSTATUS_${HttpStatus[code]}`;
+            message = this.app.meta.locale.getText(true, undefined, undefined, httpStatusMessageKey, ...args);
+        }
+        else {
+            message = this.app.meta.locale.getText(false, module, undefined, ebError ? ebError[code] : 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;
+}
+function __calcStatus(code) {
+    return typeof code !== 'string' && code < 1000 ? code : 500;
+}

package/dist/lib/bean/resource/error/errorGlobal.d.ts

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

package/dist/lib/bean/resource/error/errorGlobal.js

@@ -0,0 +1 @@
+export {};

package/dist/lib/bean/resource/error/errorObject.d.ts

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

package/dist/lib/bean/resource/error/errorObject.js

@@ -0,0 +1 @@
+export {};

package/dist/lib/bean/resource/error/index.d.ts

@@ -0,0 +1,7 @@
+export * from './beanScopeError.ts';
+export * from './beanScopeErrorImpl.ts';
+export * from './errorApplication.ts';
+export * from './errorClass.ts';
+export * from './errorGlobal.ts';
+export * from './errorObject.ts';
+export * from './type.ts';

package/dist/lib/bean/resource/error/index.js

@@ -0,0 +1,7 @@
+export * from "./beanScopeError.js";
+export * from "./beanScopeErrorImpl.js";
+export * from "./errorApplication.js";
+export * from "./errorClass.js";
+export * from "./errorGlobal.js";
+export * from "./errorObject.js";
+export * from "./type.js";

package/dist/lib/bean/resource/error/type.d.ts

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

package/dist/lib/bean/resource/error/type.js

@@ -0,0 +1 @@
+export {};

package/dist/lib/bean/resource/index.d.ts

@@ -0,0 +1,4 @@
+export * from './config/index.ts';
+export * from './constant/index.ts';
+export * from './error/index.ts';
+export * from './locale/index.ts';

package/dist/lib/bean/resource/index.js

@@ -0,0 +1,4 @@
+export * from "./config/index.js";
+export * from "./constant/index.js";
+export * from "./error/index.js";
+export * from "./locale/index.js";

package/dist/lib/bean/resource/locale/appLocale.d.ts

@@ -0,0 +1,7 @@
+import type { ILocaleInfos } from './type.ts';
+import { BeanSimple } from '../../beanSimple.ts';
+export declare class AppLocale extends BeanSimple {
+    get locale(): keyof ILocaleInfos;
+    set locale(value: keyof ILocaleInfos);
+    getText<T extends keyof ILocaleInfos>(supportCustomMessage: boolean, moduleScope: string | undefined, locale: T | undefined, key: string, ...args: any[]): string;
+}

package/dist/lib/bean/resource/locale/appLocale.js

@@ -0,0 +1,45 @@
+import * as localeutil from '@cabloy/localeutil';
+import { BeanSimple } from "../../beanSimple.js";
+import { LocaleModuleNameSeparator } from "./type.js";
+export class AppLocale extends BeanSimple {
+    get locale() {
+        return this.ctx.locale;
+    }
+    set locale(value) {
+        this.ctx.locale = value;
+    }
+    /** @internal */
+    createLocaleText(moduleScope) {
+        const self = this;
+        const getText = function (text, ...args) {
+            return self.getText(false, moduleScope, undefined, text, ...args);
+        };
+        getText.locale = function (locale, text, ...args) {
+            return self.getText(false, moduleScope, locale, text, ...args);
+        };
+        return getText;
+    }
+    /** @internal */
+    createScopeLocaleText(moduleScope, text) {
+        const self = this;
+        const getText = function (...args) {
+            return self.getText(false, moduleScope, undefined, text, ...args);
+        };
+        getText.locale = function (locale, ...args) {
+            return self.getText(false, moduleScope, locale, text, ...args);
+        };
+        return getText;
+    }
+    getText(supportCustomMessage, moduleScope, locale, key, ...args) {
+        if (!key)
+            return key;
+        if (typeof key !== 'string')
+            throw new Error(`${key} should be string`);
+        const pos = key.indexOf(LocaleModuleNameSeparator);
+        if (pos > -1) {
+            moduleScope = key.substring(0, pos);
+            key = key.substring(pos + LocaleModuleNameSeparator.length);
+        }
+        return localeutil.getLocaleText(supportCustomMessage, moduleScope ? this.app.meta.localeModules[moduleScope] : undefined, this.app.meta.locales, locale || this.locale, key, ...args);
+    }
+}

package/dist/lib/bean/resource/locale/beanScopeLocale.d.ts

@@ -0,0 +1,10 @@
+import type { IModuleLocale } from './type.ts';
+import { BeanSimple } from '../../beanSimple.ts';
+declare const BeanModuleScope: unique symbol;
+export declare class BeanScopeLocale extends BeanSimple {
+    private [BeanModuleScope];
+    private __instances;
+    constructor(moduleScope: any);
+    protected __get__(prop: string): IModuleLocale;
+}
+export {};

package/dist/lib/bean/resource/locale/beanScopeLocale.js

@@ -0,0 +1,16 @@
+import { BeanSimple } from "../../beanSimple.js";
+const BeanModuleScope = Symbol('BeanScopeLocale#ModuleScope');
+export class BeanScopeLocale extends BeanSimple {
+    [BeanModuleScope];
+    __instances = {};
+    constructor(moduleScope) {
+        super();
+        this[BeanModuleScope] = moduleScope;
+    }
+    __get__(prop) {
+        if (!this.__instances[prop]) {
+            this.__instances[prop] = this.app.meta.locale.createScopeLocaleText(this[BeanModuleScope], prop);
+        }
+        return this.__instances[prop];
+    }
+}

package/dist/lib/bean/resource/locale/index.d.ts

@@ -0,0 +1,3 @@
+export * from './appLocale.ts';
+export * from './beanScopeLocale.ts';
+export * from './type.ts';

package/dist/lib/bean/resource/locale/index.js

@@ -0,0 +1,3 @@
+export * from "./appLocale.js";
+export * from "./beanScopeLocale.js";
+export * from "./type.js";

package/dist/lib/bean/resource/locale/type.d.ts

@@ -0,0 +1,19 @@
+export declare const LocaleModuleNameSeparator = "::";
+export interface IModuleLocale {
+    (...args: any[]): string;
+    locale: <T extends keyof ILocaleInfos>(locale: T, ...args: any[]) => string;
+}
+export interface IModuleLocaleText {
+    (text: string, ...args: any[]): string;
+    locale: <T extends keyof ILocaleInfos>(locale: T, text: string, ...args: any[]) => string;
+}
+export type TypeModuleLocales<T> = {
+    [prop in keyof T]: IModuleLocale;
+};
+export type TypeLocaleBase = 'en-us';
+export interface ILocaleInfo {
+}
+export interface ILocaleInfos {
+    'en-us': ILocaleInfo;
+    'zh-cn': ILocaleInfo;
+}

package/dist/lib/bean/resource/locale/type.js

@@ -0,0 +1 @@
+export const LocaleModuleNameSeparator = '::';

package/dist/lib/bean/scope/beanScopeBase.d.ts

@@ -0,0 +1,19 @@
+import type { IModule } from '@cabloy/module-info';
+import { BeanBaseSimple } from '../beanBaseSimple.ts';
+declare const BeanModuleError: unique symbol;
+declare const BeanModuleLocale: unique symbol;
+declare const BeanModuleUtil: unique symbol;
+declare const BeanModuleModel: unique symbol;
+export declare class BeanScopeBase extends BeanBaseSimple {
+    private [BeanModuleError];
+    private [BeanModuleLocale];
+    private [BeanModuleUtil];
+    private [BeanModuleModel];
+    private __onionMetaNames;
+    private __scenes;
+    private __metas;
+    get module(): IModule;
+    private get onionMetaNames();
+    protected __get__(prop: string): any;
+}
+export {};

package/dist/lib/bean/scope/beanScopeBase.js

@@ -0,0 +1,88 @@
+import { getOnionMetasMeta } from '@cabloy/module-info';
+import { BeanBaseSimple, SymbolModuleBelong } from "../beanBaseSimple.js";
+import { BeanScopeError } from "../resource/error/beanScopeError.js";
+import { BeanScopeLocale } from "../resource/locale/beanScopeLocale.js";
+import { BeanScopeScene } from "./beanScopeScene.js";
+import { BeanScopeUtil } from "./beanScopeUtil.js";
+const BeanModuleError = Symbol('BeanScopeBase#BeanModuleError');
+const BeanModuleLocale = Symbol('BeanScopeBase#BeanModuleLocale');
+const BeanModuleUtil = Symbol('BeanScopeBase#BeanModuleUtil');
+const BeanModuleModel = Symbol('BeanScopeBase#BeanModuleModel');
+export class BeanScopeBase extends BeanBaseSimple {
+    [BeanModuleError];
+    [BeanModuleLocale];
+    [BeanModuleUtil];
+    [BeanModuleModel];
+    __onionMetaNames;
+    __scenes = {};
+    __metas = {};
+    get module() {
+        return this.app.meta.modules[this[SymbolModuleBelong]];
+    }
+    get onionMetaNames() {
+        if (!this.__onionMetaNames) {
+            this.__onionMetaNames = {};
+            const onionMetasMeta = getOnionMetasMeta(this.app.meta.modules);
+            for (const metaName in onionMetasMeta) {
+                const onionMetaMeta = onionMetasMeta[metaName];
+                if (onionMetaMeta.scopeResource) {
+                    this.__onionMetaNames[metaName] = true;
+                }
+            }
+        }
+        return this.__onionMetaNames;
+    }
+    __get__(prop) {
+        const moduleBelong = this[SymbolModuleBelong];
+        // error
+        if (prop === 'error') {
+            if (!this[BeanModuleError]) {
+                this[BeanModuleError] = this.bean._newBean(BeanScopeError, moduleBelong);
+            }
+            return this[BeanModuleError];
+        }
+        // locale
+        if (prop === 'locale') {
+            if (!this[BeanModuleLocale]) {
+                this[BeanModuleLocale] = this.bean._newBean(BeanScopeLocale, moduleBelong);
+            }
+            return this[BeanModuleLocale];
+        }
+        // config
+        if (prop === 'config') {
+            // app or ctx
+            const config = this.ctx ? this.ctx.config : this.app.config;
+            return config.modules[moduleBelong];
+        }
+        // constant
+        if (prop === 'constant') {
+            return this.app.meta.constants[moduleBelong];
+        }
+        // util
+        if (prop === 'util') {
+            if (!this[BeanModuleUtil]) {
+                this[BeanModuleUtil] = this.bean._newBean(BeanScopeUtil, moduleBelong);
+            }
+            return this[BeanModuleUtil];
+        }
+        // model
+        if (prop === 'model') {
+            if (!this[BeanModuleModel]) {
+                this[BeanModuleModel] = this.bean._newBean('a-database.service.modelResolver', moduleBelong);
+            }
+            return this[BeanModuleModel];
+        }
+        // meta
+        if (this.onionMetaNames[prop]) {
+            if (!this.__metas[prop]) {
+                this.__metas[prop] = this.bean._getBean(`${moduleBelong}.meta.${prop}`);
+            }
+            return this.__metas[prop];
+        }
+        // scene
+        if (!this.__scenes[prop]) {
+            this.__scenes[prop] = this.bean._newBean(BeanScopeScene, moduleBelong, prop);
+        }
+        return this.__scenes[prop];
+    }
+}

package/dist/lib/bean/scope/beanScopeContainer.d.ts

@@ -0,0 +1,7 @@
+import { BeanSimple } from '../beanSimple.ts';
+export interface IBeanScopeContainer {
+}
+export declare class BeanScopeContainer extends BeanSimple {
+    private __instances;
+    protected __get__(prop: string): any;
+}

package/dist/lib/bean/scope/beanScopeContainer.js

@@ -0,0 +1,15 @@
+import { splitWords } from '@cabloy/word-utils';
+import { BeanSimple } from "../beanSimple.js";
+export class BeanScopeContainer extends BeanSimple {
+    __instances = {};
+    __get__(prop) {
+        if (!this.__instances[prop]) {
+            let moduleName = splitWords(prop, true, '-');
+            if (!moduleName?.includes('-')) {
+                moduleName = `a-${moduleName}`;
+            }
+            this.__instances[prop] = this.bean.scope(moduleName);
+        }
+        return this.__instances[prop];
+    }
+}

package/dist/lib/bean/scope/beanScopeScene.d.ts

@@ -0,0 +1,11 @@
+import { BeanSimple } from '../beanSimple.ts';
+declare const BeanModuleScope: unique symbol;
+declare const BeanModuleScene: unique symbol;
+export declare class BeanScopeScene extends BeanSimple {
+    private [BeanModuleScope];
+    private [BeanModuleScene];
+    private __instances;
+    constructor(moduleScope: any, scene: any);
+    protected __get__(prop: string): any;
+}
+export {};