vona-core 1.0.0 → 5.0.10

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

@@ -0,0 +1,20 @@
+import { BeanSimple } from "../beanSimple.js";
+const BeanModuleScope = Symbol('BeanScopeScene#ModuleScope');
+const BeanModuleScene = Symbol('BeanScopeScene#BeanModuleScene');
+export class BeanScopeScene extends BeanSimple {
+    [BeanModuleScope];
+    [BeanModuleScene];
+    __instances = {};
+    constructor(moduleScope, scene) {
+        super();
+        this[BeanModuleScope] = moduleScope;
+        this[BeanModuleScene] = scene;
+    }
+    __get__(prop) {
+        if (!this.__instances[prop]) {
+            const beanFullName = `${this[BeanModuleScope]}.${this[BeanModuleScene]}.${prop}`;
+            this.__instances[prop] = this.bean._injectBeanInstanceProp(this, beanFullName, {});
+        }
+        return this.__instances[prop];
+    }
+}

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

@@ -0,0 +1,10 @@
+import { BeanSimple } from '../beanSimple.ts';
+declare const BeanModuleScope: unique symbol;
+export declare class BeanScopeUtil extends BeanSimple {
+    private [BeanModuleScope];
+    constructor(moduleScope: any);
+    combineApiPath(path: string | undefined, prefix?: string | boolean, simplify?: boolean): string;
+    combineResourceName(resourceName: string | undefined, simplify?: boolean, simplifyProviderId?: boolean): string;
+    combineStaticPath(path: string | undefined): string;
+}
+export {};

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

@@ -0,0 +1,18 @@
+import { BeanSimple } from "../beanSimple.js";
+const BeanModuleScope = Symbol('BeanScopeScene#ModuleScope');
+export class BeanScopeUtil extends BeanSimple {
+    [BeanModuleScope];
+    constructor(moduleScope) {
+        super();
+        this[BeanModuleScope] = moduleScope;
+    }
+    combineApiPath(path, prefix, simplify) {
+        return this.app.util.combineApiPath(path, this[BeanModuleScope], prefix, simplify);
+    }
+    combineResourceName(resourceName, simplify, simplifyProviderId) {
+        return this.app.util.combineResourceName(resourceName, this[BeanModuleScope], simplify, simplifyProviderId);
+    }
+    combineStaticPath(path) {
+        return this.app.util.combineStaticPath(path, this[BeanModuleScope]);
+    }
+}

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

@@ -0,0 +1,4 @@
+export * from './beanScopeBase.ts';
+export * from './beanScopeContainer.ts';
+export * from './beanScopeScene.ts';
+export * from './beanScopeUtil.ts';

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

@@ -0,0 +1,4 @@
+export * from "./beanScopeBase.js";
+export * from "./beanScopeContainer.js";
+export * from "./beanScopeScene.js";
+export * from "./beanScopeUtil.js";

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

@@ -0,0 +1,21 @@
+/** bean merge: bean.instance */
+import type { IBeanSceneRecord } from '../decorator/interface/beanOptions.ts';
+export interface IBeanRecordGlobal {
+}
+export interface IBeanRecordGeneral {
+}
+export type TypeBeanRecordGeneralSelector<SCENE extends keyof IBeanSceneRecord> = {
+    [K in keyof IBeanRecordGeneral as K extends `${string}.${SCENE}.${string}` ? K : never]: IBeanRecordGeneral[K];
+};
+export type TypeBeanRecordGeneralSelectorKeys<SCENE extends keyof IBeanSceneRecord> = keyof TypeBeanRecordGeneralSelector<SCENE>;
+export type IBeanRecord = IBeanRecordGlobal & IBeanRecordGeneral;
+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;

package/dist/lib/bean/type.js

@@ -0,0 +1,2 @@
+/** bean merge: bean.instance */
+export {};

package/dist/lib/core/application.d.ts

@@ -0,0 +1,25 @@
+import type { Server } from 'node:http';
+import type { VonaApplicationOptions } from '../../types/application/app.ts';
+import type { VonaConfig } from '../../types/config/config.ts';
+import type { VonaContext } from '../../types/context/index.ts';
+import type { ApplicationError } from '../bean/resource/error/errorApplication.ts';
+import KoaApplication from 'koa';
+import { BeanContainer } from '../bean/beanContainer.ts';
+import { AppUtil } from '../utils/util.ts';
+import { VonaAsyncLocalStorage } from './asyncLocalStorage.ts';
+import { AppMeta } from './meta.ts';
+export interface VonaApplication extends ApplicationError {
+}
+export declare class VonaApplication extends KoaApplication {
+    options: VonaApplicationOptions;
+    config: VonaConfig;
+    bean: BeanContainer;
+    util: AppUtil;
+    meta: AppMeta;
+    server: Server;
+    ctxStorage: VonaAsyncLocalStorage;
+    constructor(options: VonaApplicationOptions);
+    get ctx(): VonaContext;
+    get name(): string;
+    createAnonymousContext(req?: any, res?: any): VonaContext;
+}

package/dist/lib/core/application.js

@@ -0,0 +1,78 @@
+import http from 'node:http';
+import KoaApplication from 'koa';
+import { cast } from "../../types/utils/cast.js";
+import { BeanContainer } from "../bean/beanContainer.js";
+import { AppUtil } from "../utils/util.js";
+import { VonaAsyncLocalStorage } from "./asyncLocalStorage.js";
+import { contextBase } from "./context.js";
+import { AppMeta } from "./meta.js";
+export class VonaApplication extends KoaApplication {
+    options;
+    config;
+    bean;
+    util;
+    meta;
+    server;
+    ctxStorage;
+    constructor(options) {
+        const env = options.env;
+        const koaOptions = {
+            env: cast(env).NODE_ENV,
+            keys: options.config.server.keys,
+            proxy: options.config.proxy.enabled,
+            subdomainOffset: options.config.server.subdomainOffset,
+            proxyIpHeader: options.config.proxy.ipHeaders,
+            maxIpsCount: options.config.proxy.maxIpsCount,
+            asyncLocalStorage: false,
+        };
+        super(koaOptions);
+        this.options = options;
+        this.config = options.config;
+        this.bean = BeanContainer.create(this, undefined);
+        this.util = this.bean._newBean(AppUtil);
+        this.meta = this.bean._newBean(AppMeta, env);
+        // asyncLocalStorage
+        this.ctxStorage = new VonaAsyncLocalStorage(this);
+        // app.context
+        for (const key of Reflect.ownKeys(contextBase)) {
+            const desc = Object.getOwnPropertyDescriptor(contextBase, key);
+            Object.defineProperty(this.context, key, desc);
+        }
+    }
+    get ctx() {
+        return this.currentContext;
+    }
+    get name() {
+        return this.options.name;
+    }
+    createAnonymousContext(req, res) {
+        let request;
+        if (req) {
+            request = req;
+        }
+        else {
+            const host = `localhost:${this.meta.env.SERVER_LISTEN_PORT}`;
+            request = {
+                headers: {
+                    'host': host,
+                    'x-forwarded-for': host,
+                },
+                query: {},
+                querystring: '',
+                host,
+                hostname: 'localhost',
+                protocol: 'http',
+                secure: 'false',
+                method: 'POST',
+                url: '/',
+                path: '/',
+                socket: {
+                    remoteAddress: '127.0.0.1',
+                    remotePort: 7001,
+                },
+            };
+        }
+        const response = res ?? new http.ServerResponse(request);
+        return this.createContext(request, response);
+    }
+}

package/dist/lib/core/asyncLocalStorage.d.ts

@@ -0,0 +1,8 @@
+import type { VonaContext } from '../../types/context/index.ts';
+import type { VonaApplication } from './application.ts';
+import { AsyncLocalStorage } from 'node:async_hooks';
+export declare class VonaAsyncLocalStorage extends AsyncLocalStorage<VonaContext> {
+    app: VonaApplication;
+    constructor(app: VonaApplication);
+    run<R>(store: VonaContext, callback: () => R): Promise<R>;
+}

package/dist/lib/core/asyncLocalStorage.js

@@ -0,0 +1,23 @@
+import { AsyncLocalStorage } from 'node:async_hooks';
+export class VonaAsyncLocalStorage extends AsyncLocalStorage {
+    app;
+    constructor(app) {
+        super();
+        this.app = app;
+    }
+    async run(store, callback, ...args) {
+        if (store === this.app.currentContext) {
+            return await callback(...args);
+        }
+        return super.run(store, async (...args) => {
+            try {
+                this.app.meta.ctxCounter.increment();
+                return await callback(...args);
+            }
+            finally {
+                await store.bean.dispose();
+                this.app.meta.ctxCounter.decrement();
+            }
+        }, ...args);
+    }
+}

package/dist/lib/core/config.d.ts

@@ -0,0 +1,12 @@
+import type { VonaAppInfo } from '../../types/application/app.ts';
+import type { VonaConfigOptional } from '../../types/config/config.ts';
+import type { VonaConfigEnv } from '../../types/utils/env.ts';
+import type { PowerPartial } from '../../types/utils/powerPartial.ts';
+import type { VonaApplication } from './application.ts';
+export declare function combineAppConfigDefault(appInfo: VonaAppInfo, env: VonaConfigEnv): PowerPartial<import("../../types/config/config.ts").VonaConfig>;
+export declare function configDefault(appInfo: VonaAppInfo, env: VonaConfigEnv): VonaConfigOptional;
+export declare function configLocal(_env: VonaConfigEnv): VonaConfigOptional;
+export declare function configProd(_env: VonaConfigEnv): VonaConfigOptional;
+export declare function configTest(_env: VonaConfigEnv): VonaConfigOptional;
+export type TypeConfigLoader<T> = (app: VonaApplication) => Promise<PowerPartial<T>>;
+export declare function combineConfigDefault<T>(app: VonaApplication, configDefault: TypeConfigLoader<T>, configLocal?: TypeConfigLoader<T>, configProd?: TypeConfigLoader<T>, configTest?: TypeConfigLoader<T>): Promise<PowerPartial<T>>;

package/dist/lib/core/config.js

@@ -0,0 +1,120 @@
+import os from 'node:os';
+import path from 'node:path';
+import fse from 'fs-extra';
+import { cast } from "../../types/utils/cast.js";
+import { deepExtend } from "../utils/util.js";
+import { combineLoggerDefault } from "./loggerDefault.js";
+export function combineAppConfigDefault(appInfo, env) {
+    let config = configDefault(appInfo, env);
+    const mode = appInfo.configMeta.mode;
+    if (mode === 'local') {
+        config = deepExtend(config, configLocal(env));
+    }
+    else if (mode === 'prod') {
+        config = deepExtend(config, configProd(env));
+    }
+    else if (mode === 'test') {
+        config = deepExtend(config, configTest(env));
+    }
+    return config;
+}
+export function configDefault(appInfo, env) {
+    // server
+    const publicDir = env.SERVER_PUBLICDIR || getPublicPathPhysicalRoot(appInfo);
+    const loggerDir = env.SERVER_LOGGERDIR || getLoggerPathPhysicalRoot(appInfo);
+    const subdomainOffset = Number.parseInt(env.SERVER_SUBDOMAINOFFSET || '1');
+    const workers = Number.parseInt(env.SERVER_WORKERS);
+    // logger
+    const logger = combineLoggerDefault(appInfo);
+    return {
+        meta: {
+            flavor: cast(env).META_FLAVOR,
+            mode: cast(env).META_MODE,
+        },
+        server: {
+            keys: (env.SERVER_KEYS || '').split(','),
+            globalPrefix: env.SERVER_GLOBALPREFIX || '/api',
+            publicDir,
+            loggerDir,
+            subdomainOffset,
+            workers,
+            listen: {
+                hostname: env.SERVER_LISTEN_HOSTNAME,
+                port: Number.parseInt(env.SERVER_LISTEN_PORT),
+                disable: env.SERVER_LISTEN_DISABLE === 'true',
+            },
+            serve: {},
+        },
+        proxy: {
+            enabled: true,
+            ipHeaders: 'x-real-ip,x-forwarded-for',
+            hostHeaders: 'x-forwarded-host,host',
+            protocolHeaders: 'x-forwarded-proto',
+            maxProxyCount: 1,
+            maxIpsCount: 15,
+        },
+        logger,
+        //
+        instances: [],
+        modules: {},
+    };
+}
+export function configLocal(_env) {
+    return {
+        proxy: {
+            enabled: true,
+        },
+    };
+}
+export function configProd(_env) {
+    return {
+        proxy: {
+            enabled: true,
+        },
+    };
+}
+export function configTest(_env) {
+    return {
+        proxy: {
+            enabled: false,
+        },
+    };
+}
+function getLoggerPathPhysicalRoot(appInfo) {
+    const mode = appInfo.configMeta.mode;
+    let loggerDir;
+    if (mode === 'test' || mode === 'local') {
+        loggerDir = path.join(appInfo.projectPath, '.app/logs');
+    }
+    else {
+        loggerDir = path.join(os.homedir(), 'vona', appInfo.name, 'logs');
+    }
+    fse.ensureDirSync(loggerDir);
+    return loggerDir;
+}
+function getPublicPathPhysicalRoot(appInfo) {
+    const mode = appInfo.configMeta.mode;
+    let publicDir;
+    if (mode === 'test' || mode === 'local') {
+        publicDir = path.join(appInfo.projectPath, '.app/public');
+    }
+    else {
+        publicDir = path.join(os.homedir(), 'vona', appInfo.name, 'public');
+    }
+    fse.ensureDirSync(publicDir);
+    return publicDir;
+}
+export async function combineConfigDefault(app, configDefault, configLocal, configProd, configTest) {
+    let config = await configDefault(app);
+    const mode = app.config.meta.mode;
+    if (mode === 'local' && configLocal) {
+        config = deepExtend(config, await configLocal(app));
+    }
+    else if (mode === 'prod' && configProd) {
+        config = deepExtend(config, await configProd(app));
+    }
+    else if (mode === 'test' && configTest) {
+        config = deepExtend(config, await configTest(app));
+    }
+    return config;
+}

package/dist/lib/core/context.d.ts

@@ -0,0 +1,2 @@
+import type { ContextBase } from '../../types/context/contextBase.ts';
+export declare const contextBase: ContextBase;

package/dist/lib/core/context.js

@@ -0,0 +1,104 @@
+import { cast } from "../../types/utils/cast.js";
+import { BeanContainer } from "../bean/beanContainer.js";
+import { appResource } from "./resource.js";
+const BEAN = Symbol.for('Context#__bean');
+const INNERACCESS = Symbol.for('Context#__inneraccess');
+const CTXCALLER = Symbol.for('Context#__ctxcaller');
+const ONIONSDYNAMIC = Symbol.for('Context#__onionsdynamic');
+export const contextBase = {
+    get bean() {
+        const self = cast(this);
+        if (!self[BEAN]) {
+            self[BEAN] = BeanContainer.create(self.app, self);
+        }
+        return self[BEAN];
+    },
+    get locale() {
+        const self = cast(this);
+        return self.__getLocale();
+    },
+    set locale(value) {
+        const self = cast(this);
+        self.__setLocale(value);
+    },
+    get instanceName() {
+        const self = cast(this);
+        return self.__getInstanceName();
+    },
+    set instanceName(value) {
+        const self = cast(this);
+        self.__setInstanceName(value);
+    },
+    get config() {
+        const self = cast(this);
+        const serviceInstance = cast(self.app.bean._getBean('a-instance.service.instance'));
+        return serviceInstance.getConfig(self.instanceName) || self.app.config;
+    },
+    get innerAccess() {
+        return this[INNERACCESS];
+    },
+    set innerAccess(value) {
+        this[INNERACCESS] = value;
+    },
+    get ctxCaller() {
+        return this[CTXCALLER];
+    },
+    set ctxCaller(value) {
+        this[CTXCALLER] = value;
+    },
+    getController() {
+        const self = cast(this);
+        return self.route?.controller;
+    },
+    getControllerPrototype() {
+        const self = cast(this);
+        const controller = self.getController();
+        if (!controller)
+            return undefined;
+        return controller.prototype;
+    },
+    getControllerBeanFullName() {
+        const self = cast(this);
+        const controller = self.getController();
+        if (!controller)
+            return undefined;
+        const beanOptions = appResource.getBean(controller);
+        return beanOptions?.beanFullName;
+    },
+    getHandler() {
+        const self = cast(this);
+        return self.route?.actionDescriptor?.value;
+    },
+    getHandlerName() {
+        const self = cast(this);
+        return self.route?.action;
+    },
+    get onionsDynamic() {
+        return this[ONIONSDYNAMIC];
+    },
+    set onionsDynamic(value) {
+        this[ONIONSDYNAMIC] = value;
+    },
+    get acceptJSON() {
+        const self = cast(this);
+        if (self.path.endsWith('.json'))
+            return true;
+        if (self.response.type && self.response.type.includes('json'))
+            return true;
+        if (self.accepts('html', 'text', 'json') === 'json')
+            return true;
+        return false;
+    },
+    redirect(url, status) {
+        const self = cast(this);
+        // checkOrigin
+        if (!url.startsWith('/')) {
+            const origin = cast(self.app.bean).security.checkOrigin(url, self.host);
+            if (!origin)
+                self.app.throw(403);
+        }
+        // throw
+        status = status ?? 302;
+        self.app.throw(status, url);
+    },
+};

package/dist/lib/core/ctxCounter.d.ts

@@ -0,0 +1,7 @@
+export declare class CtxCounter {
+    private _ctxCounter;
+    get current(): number;
+    increment(): number;
+    decrement(): number;
+    awaitUntilZero(): Promise<void>;
+}

package/dist/lib/core/ctxCounter.js

@@ -0,0 +1,20 @@
+import { sleep } from '@cabloy/utils';
+export class CtxCounter {
+    _ctxCounter = 0;
+    get current() {
+        return this._ctxCounter;
+    }
+    increment() {
+        return ++this._ctxCounter;
+    }
+    decrement() {
+        return --this._ctxCounter;
+    }
+    async awaitUntilZero() {
+        while (true) {
+            if (this.current === 0)
+                break;
+            await sleep(200);
+        }
+    }
+}

package/dist/lib/core/index.d.ts

@@ -0,0 +1,6 @@
+export * from './application.ts';
+export * from './config.ts';
+export * from './locales.ts';
+export * from './meta.ts';
+export * from './metadata.ts';
+export * from './resource.ts';

package/dist/lib/core/index.js

@@ -0,0 +1,6 @@
+export * from "./application.js";
+export * from "./config.js";
+export * from "./locales.js";
+export * from "./meta.js";
+export * from "./metadata.js";
+export * from "./resource.js";

package/dist/lib/core/locales.d.ts

@@ -0,0 +1,137 @@
+declare const _default: {
+    'en-us': {
+        ValidationFailedDev: string;
+        HTTPSTATUS_SUCCESS: string;
+        HTTPSTATUS_UNKNOWN_ERROR: string;
+        HTTPSTATUS_CONTINUE: string;
+        HTTPSTATUS_SWITCHING_PROTOCOLS: string;
+        HTTPSTATUS_PROCESSING: string;
+        HTTPSTATUS_EARLYHINTS: string;
+        HTTPSTATUS_OK: string;
+        HTTPSTATUS_CREATED: string;
+        HTTPSTATUS_ACCEPTED: string;
+        HTTPSTATUS_NON_AUTHORITATIVE_INFORMATION: string;
+        HTTPSTATUS_NO_CONTENT: string;
+        HTTPSTATUS_RESET_CONTENT: string;
+        HTTPSTATUS_PARTIAL_CONTENT: string;
+        HTTPSTATUS_MULTI_STATUS: string;
+        HTTPSTATUS_ALREADY_REPORTED: string;
+        HTTPSTATUS_IM_USED: string;
+        HTTPSTATUS_MULTIPLE_CHOICES: string;
+        HTTPSTATUS_MOVED_PERMANENTLY: string;
+        HTTPSTATUS_FOUND: string;
+        HTTPSTATUS_SEE_OTHER: string;
+        HTTPSTATUS_NOT_MODIFIED: string;
+        HTTPSTATUS_USE_PROXY: string;
+        HTTPSTATUS_TEMPORARY_REDIRECT: string;
+        HTTPSTATUS_PERMANENT_REDIRECT: string;
+        HTTPSTATUS_BAD_REQUEST: string;
+        HTTPSTATUS_UNAUTHORIZED: string;
+        HTTPSTATUS_PAYMENT_REQUIRED: string;
+        HTTPSTATUS_FORBIDDEN: string;
+        HTTPSTATUS_NOT_FOUND: string;
+        HTTPSTATUS_METHOD_NOT_ALLOWED: string;
+        HTTPSTATUS_NOT_ACCEPTABLE: string;
+        HTTPSTATUS_PROXY_AUTHENTICATION_REQUIRED: string;
+        HTTPSTATUS_REQUEST_TIMEOUT: string;
+        HTTPSTATUS_CONFLICT: string;
+        HTTPSTATUS_GONE: string;
+        HTTPSTATUS_LENGTH_REQUIRED: string;
+        HTTPSTATUS_PRECONDITION_FAILED: string;
+        HTTPSTATUS_PAYLOAD_TOO_LARGE: string;
+        HTTPSTATUS_URI_TOO_LONG: string;
+        HTTPSTATUS_UNSUPPORTED_MEDIA_TYPE: string;
+        HTTPSTATUS_REQUESTED_RANGE_NOT_SATISFIABLE: string;
+        HTTPSTATUS_EXPECTATION_FAILED: string;
+        HTTPSTATUS_I_AM_A_TEAPOT: string;
+        HTTPSTATUS_MISDIRECTED: string;
+        HTTPSTATUS_UNPROCESSABLE_CONTENT: string;
+        HTTPSTATUS_LOCKED: string;
+        HTTPSTATUS_FAILED_DEPENDENCY: string;
+        HTTPSTATUS_TOO_EARLY: string;
+        HTTPSTATUS_UPGRADE_REQUIRED: string;
+        HTTPSTATUS_PRECONDITION_REQUIRED: string;
+        HTTPSTATUS_TOO_MANY_REQUESTS: string;
+        HTTPSTATUS_REQUEST_HEADER_FIELDS_TOO_LARGE: string;
+        HTTPSTATUS_UNAVAILABLE_FOR_LEGAL_REASONS: string;
+        HTTPSTATUS_INTERNAL_SERVER_ERROR: string;
+        HTTPSTATUS_NOT_IMPLEMENTED: string;
+        HTTPSTATUS_BAD_GATEWAY: string;
+        HTTPSTATUS_SERVICE_UNAVAILABLE: string;
+        HTTPSTATUS_GATEWAY_TIMEOUT: string;
+        HTTPSTATUS_HTTP_VERSION_NOT_SUPPORTED: string;
+        HTTPSTATUS_VARIANT_ALSO_NEGOTIATES: string;
+        HTTPSTATUS_INSUFFICIENT_STORAGE: string;
+        HTTPSTATUS_LOOP_DETECTED: string;
+        HTTPSTATUS_BANDWIDTH_LIMIT_EXCEEDED: string;
+        HTTPSTATUS_NETWORK_AUTHENTICATION_REQUIRED: string;
+    };
+    'zh-cn': {
+        ValidationFailedDev: string;
+        HTTPSTATUS_SUCCESS: string;
+        HTTPSTATUS_UNKNOWN_ERROR: string;
+        HTTPSTATUS_CONTINUE: string;
+        HTTPSTATUS_SWITCHING_PROTOCOLS: string;
+        HTTPSTATUS_PROCESSING: string;
+        HTTPSTATUS_EARLYHINTS: string;
+        HTTPSTATUS_OK: string;
+        HTTPSTATUS_CREATED: string;
+        HTTPSTATUS_ACCEPTED: string;
+        HTTPSTATUS_NON_AUTHORITATIVE_INFORMATION: string;
+        HTTPSTATUS_NO_CONTENT: string;
+        HTTPSTATUS_RESET_CONTENT: string;
+        HTTPSTATUS_PARTIAL_CONTENT: string;
+        HTTPSTATUS_MULTI_STATUS: string;
+        HTTPSTATUS_ALREADY_REPORTED: string;
+        HTTPSTATUS_IM_USED: string;
+        HTTPSTATUS_MULTIPLE_CHOICES: string;
+        HTTPSTATUS_MOVED_PERMANENTLY: string;
+        HTTPSTATUS_FOUND: string;
+        HTTPSTATUS_SEE_OTHER: string;
+        HTTPSTATUS_NOT_MODIFIED: string;
+        HTTPSTATUS_USE_PROXY: string;
+        HTTPSTATUS_TEMPORARY_REDIRECT: string;
+        HTTPSTATUS_PERMANENT_REDIRECT: string;
+        HTTPSTATUS_BAD_REQUEST: string;
+        HTTPSTATUS_UNAUTHORIZED: string;
+        HTTPSTATUS_PAYMENT_REQUIRED: string;
+        HTTPSTATUS_FORBIDDEN: string;
+        HTTPSTATUS_NOT_FOUND: string;
+        HTTPSTATUS_METHOD_NOT_ALLOWED: string;
+        HTTPSTATUS_NOT_ACCEPTABLE: string;
+        HTTPSTATUS_PROXY_AUTHENTICATION_REQUIRED: string;
+        HTTPSTATUS_REQUEST_TIMEOUT: string;
+        HTTPSTATUS_CONFLICT: string;
+        HTTPSTATUS_GONE: string;
+        HTTPSTATUS_LENGTH_REQUIRED: string;
+        HTTPSTATUS_PRECONDITION_FAILED: string;
+        HTTPSTATUS_PAYLOAD_TOO_LARGE: string;
+        HTTPSTATUS_URI_TOO_LONG: string;
+        HTTPSTATUS_UNSUPPORTED_MEDIA_TYPE: string;
+        HTTPSTATUS_REQUESTED_RANGE_NOT_SATISFIABLE: string;
+        HTTPSTATUS_EXPECTATION_FAILED: string;
+        HTTPSTATUS_I_AM_A_TEAPOT: string;
+        HTTPSTATUS_MISDIRECTED: string;
+        HTTPSTATUS_UNPROCESSABLE_CONTENT: string;
+        HTTPSTATUS_LOCKED: string;
+        HTTPSTATUS_FAILED_DEPENDENCY: string;
+        HTTPSTATUS_TOO_EARLY: string;
+        HTTPSTATUS_UPGRADE_REQUIRED: string;
+        HTTPSTATUS_PRECONDITION_REQUIRED: string;
+        HTTPSTATUS_TOO_MANY_REQUESTS: string;
+        HTTPSTATUS_REQUEST_HEADER_FIELDS_TOO_LARGE: string;
+        HTTPSTATUS_UNAVAILABLE_FOR_LEGAL_REASONS: string;
+        HTTPSTATUS_INTERNAL_SERVER_ERROR: string;
+        HTTPSTATUS_NOT_IMPLEMENTED: string;
+        HTTPSTATUS_BAD_GATEWAY: string;
+        HTTPSTATUS_SERVICE_UNAVAILABLE: string;
+        HTTPSTATUS_GATEWAY_TIMEOUT: string;
+        HTTPSTATUS_HTTP_VERSION_NOT_SUPPORTED: string;
+        HTTPSTATUS_VARIANT_ALSO_NEGOTIATES: string;
+        HTTPSTATUS_INSUFFICIENT_STORAGE: string;
+        HTTPSTATUS_LOOP_DETECTED: string;
+        HTTPSTATUS_BANDWIDTH_LIMIT_EXCEEDED: string;
+        HTTPSTATUS_NETWORK_AUTHENTICATION_REQUIRED: string;
+    };
+};
+export default _default;

package/dist/lib/core/locales.js

@@ -0,0 +1,6 @@
+import enUs from "../locale/en-us.js";
+import zhCn from "../locale/zh-cn.js";
+export default {
+    'en-us': enUs,
+    'zh-cn': zhCn,
+};