@midwayjs/decorator 3.0.0-beta.9 → 3.0.4

package/dist/decorator/common/objectDef.d.ts

@@ -1,5 +1,7 @@
 import { ScopeEnum } from '../../index';
 export declare function Init(): MethodDecorator;
 export declare function Destroy(): MethodDecorator;
-export declare function Scope(scope: ScopeEnum): ClassDecorator;
+export declare function Scope(scope: ScopeEnum, scopeOptions?: {
+    allowDowngrade?: boolean;
+}): ClassDecorator;
 //# sourceMappingURL=objectDef.d.ts.map

package/dist/decorator/common/objectDef.js

@@ -16,9 +16,9 @@ function Destroy() {
     };
 }
 exports.Destroy = Destroy;
-function Scope(scope) {
+function Scope(scope, scopeOptions) {
     return function (target) {
-        (0, index_1.saveObjectDefinition)(target, { scope });
+        (0, index_1.saveObjectDefinition)(target, { scope, ...scopeOptions });
     };
 }
 exports.Scope = Scope;

package/dist/decorator/web/paramMapping.d.ts

@@ -1,20 +1,3 @@
-export interface GetFileStreamOptions {
-    requireFile?: boolean;
-    defCharset?: string;
-    limits?: {
-        fieldNameSize?: number;
-        fieldSize?: number;
-        fields?: number;
-        fileSize?: number;
-        files?: number;
-        parts?: number;
-        headerPairs?: number;
-    };
-    checkFile?(fieldname: string, file: any, filename: string, encoding: string, mimetype: string): void | Error;
-}
-export interface GetFilesStreamOptions extends GetFileStreamOptions {
-    autoFields?: boolean;
-}
 export declare enum RouteParamTypes {
     QUERY = 0,
     BODY = 1,
@@ -26,7 +9,8 @@ export declare enum RouteParamTypes {
     NEXT = 7,
     REQUEST_PATH = 8,
     REQUEST_IP = 9,
-    QUERIES = 10
+    QUERIES = 10,
+    FIELDS = 11
 }
 export interface RouterParamValue {
     index: number;
@@ -38,9 +22,10 @@ export declare const Body: (property?: string) => ParameterDecorator;
 export declare const Query: (property?: string) => ParameterDecorator;
 export declare const Param: (property?: string) => ParameterDecorator;
 export declare const Headers: (property?: string) => ParameterDecorator;
-export declare const File: (property?: GetFileStreamOptions) => ParameterDecorator;
-export declare const Files: (property?: GetFilesStreamOptions) => ParameterDecorator;
+export declare const File: (property?: any) => ParameterDecorator;
+export declare const Files: (property?: any) => ParameterDecorator;
 export declare const RequestPath: () => ParameterDecorator;
 export declare const RequestIP: () => ParameterDecorator;
 export declare const Queries: (property?: string) => ParameterDecorator;
+export declare const Fields: (property?: string) => ParameterDecorator;
 //# sourceMappingURL=paramMapping.d.ts.map

package/dist/decorator/web/paramMapping.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Queries = exports.RequestIP = exports.RequestPath = exports.Files = exports.File = exports.Headers = exports.Param = exports.Query = exports.Body = exports.Session = exports.RouteParamTypes = void 0;
+exports.Fields = exports.Queries = exports.RequestIP = exports.RequestPath = exports.Files = exports.File = exports.Headers = exports.Param = exports.Query = exports.Body = exports.Session = exports.RouteParamTypes = void 0;
 const __1 = require("../../");
 var RouteParamTypes;
 (function (RouteParamTypes) {
@@ -15,6 +15,7 @@ var RouteParamTypes;
     RouteParamTypes[RouteParamTypes["REQUEST_PATH"] = 8] = "REQUEST_PATH";
     RouteParamTypes[RouteParamTypes["REQUEST_IP"] = 9] = "REQUEST_IP";
     RouteParamTypes[RouteParamTypes["QUERIES"] = 10] = "QUERIES";
+    RouteParamTypes[RouteParamTypes["FIELDS"] = 11] = "FIELDS";
 })(RouteParamTypes = exports.RouteParamTypes || (exports.RouteParamTypes = {}));
 const createParamMapping = function (type) {
     return (propertyData) => {
@@ -44,4 +45,6 @@ const RequestIP = () => createParamMapping(RouteParamTypes.REQUEST_IP)();
 exports.RequestIP = RequestIP;
 const Queries = (property) => createParamMapping(RouteParamTypes.QUERIES)(property);
 exports.Queries = Queries;
+const Fields = (property) => createParamMapping(RouteParamTypes.FIELDS)(property);
+exports.Fields = Fields;
 //# sourceMappingURL=paramMapping.js.map

package/dist/decorator/web/requestMapping.d.ts

@@ -22,10 +22,12 @@ export interface RouterOption {
     middleware?: MiddlewareParamArray;
     /**
      * router summary, for swagger
+     * @deprecated
      */
     summary?: string;
     /**
      * router description, for swagger
+     * @deprecated
      */
     description?: string;
     /**

package/dist/decoratorManager.d.ts

@@ -281,8 +281,21 @@ export declare function getMethodReturnTypes(target: any, methodName: string | s
  * create a custom property inject
  * @param decoratorKey
  * @param metadata
+ * @param impl default true, configuration need decoratorService.registerMethodHandler
  */
-export declare function createCustomPropertyDecorator(decoratorKey: string, metadata: any): PropertyDecorator;
-export declare function createCustomMethodDecorator(decoratorKey: string, metadata: any): MethodDecorator;
-export declare function createCustomParamDecorator(decoratorKey: string, metadata: any): ParameterDecorator;
+export declare function createCustomPropertyDecorator(decoratorKey: string, metadata: any, impl?: boolean): PropertyDecorator;
+/**
+ *
+ * @param decoratorKey
+ * @param metadata
+ * @param impl default true, configuration need decoratorService.registerMethodHandler
+ */
+export declare function createCustomMethodDecorator(decoratorKey: string, metadata: any, impl?: boolean): MethodDecorator;
+/**
+ *
+ * @param decoratorKey
+ * @param metadata
+ * @param impl default true, configuration need decoratorService.registerMethodHandler
+ */
+export declare function createCustomParamDecorator(decoratorKey: string, metadata: any, impl?: boolean): ParameterDecorator;
 //# sourceMappingURL=decoratorManager.d.ts.map

package/dist/decoratorManager.js

@@ -4,6 +4,7 @@ exports.createCustomParamDecorator = exports.createCustomMethodDecorator = expor
 require("reflect-metadata");
 const constant_1 = require("./constant");
 const util_1 = require("./util");
+const camelCase_1 = require("./util/camelCase");
 const debug = require('util').debuglog('midway:decorator');
 exports.PRELOAD_MODULE_KEY = 'INJECTION_PRELOAD_MODULE_KEY';
 exports.INJECT_CLASS_KEY_PREFIX = 'INJECTION_CLASS_META_DATA';
@@ -565,7 +566,7 @@ function saveProviderId(identifier, target) {
             id: identifier,
             originName: target.name,
             uuid,
-            name: (0, util_1.classNamed)(target.name),
+            name: (0, camelCase_1.camelCase)(target.name),
         }, target);
         debug(`save provide: ${target.name} -> ${uuid}`);
     }
@@ -650,28 +651,43 @@ exports.getMethodReturnTypes = getMethodReturnTypes;
  * create a custom property inject
  * @param decoratorKey
  * @param metadata
+ * @param impl default true, configuration need decoratorService.registerMethodHandler
  */
-function createCustomPropertyDecorator(decoratorKey, metadata) {
+function createCustomPropertyDecorator(decoratorKey, metadata, impl = true) {
     return function (target, propertyName) {
         attachClassMetadata(constant_1.INJECT_CUSTOM_PROPERTY, {
             propertyName,
             key: decoratorKey,
             metadata,
+            impl,
         }, target, propertyName);
     };
 }
 exports.createCustomPropertyDecorator = createCustomPropertyDecorator;
-function createCustomMethodDecorator(decoratorKey, metadata) {
+/**
+ *
+ * @param decoratorKey
+ * @param metadata
+ * @param impl default true, configuration need decoratorService.registerMethodHandler
+ */
+function createCustomMethodDecorator(decoratorKey, metadata, impl = true) {
     return function (target, propertyName, descriptor) {
         attachClassMetadata(constant_1.INJECT_CUSTOM_METHOD, {
             propertyName,
             key: decoratorKey,
             metadata,
+            impl,
         }, target);
     };
 }
 exports.createCustomMethodDecorator = createCustomMethodDecorator;
-function createCustomParamDecorator(decoratorKey, metadata) {
+/**
+ *
+ * @param decoratorKey
+ * @param metadata
+ * @param impl default true, configuration need decoratorService.registerMethodHandler
+ */
+function createCustomParamDecorator(decoratorKey, metadata, impl = true) {
     return function (target, propertyName, parameterIndex) {
         // const parameterName = getParamNames(target[methodName])[parameterIndex];
         attachClassMetadata(constant_1.INJECT_CUSTOM_PARAM, {
@@ -679,6 +695,7 @@ function createCustomParamDecorator(decoratorKey, metadata) {
             parameterIndex,
             propertyName,
             metadata,
+            impl,
         }, target, propertyName, 'multi');
     };
 }

package/dist/index.d.ts

@@ -2,5 +2,7 @@ export * from './decorator';
 export * from './interface';
 export * from './constant';
 export * from './decoratorManager';
-export * from './util/index';
+export { Types, Utils, sleep } from './util/index';
+export { FileUtils } from './util/fs';
+export * from './util/format';
 //# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -10,9 +10,16 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.FileUtils = exports.sleep = exports.Utils = exports.Types = void 0;
 __exportStar(require("./decorator"), exports);
 __exportStar(require("./interface"), exports);
 __exportStar(require("./constant"), exports);
 __exportStar(require("./decoratorManager"), exports);
-__exportStar(require("./util/index"), exports);
+var index_1 = require("./util/index");
+Object.defineProperty(exports, "Types", { enumerable: true, get: function () { return index_1.Types; } });
+Object.defineProperty(exports, "Utils", { enumerable: true, get: function () { return index_1.Utils; } });
+Object.defineProperty(exports, "sleep", { enumerable: true, get: function () { return index_1.sleep; } });
+var fs_1 = require("./util/fs");
+Object.defineProperty(exports, "FileUtils", { enumerable: true, get: function () { return fs_1.FileUtils; } });
+__exportStar(require("./util/format"), exports);
 //# sourceMappingURL=index.js.map

package/dist/interface.d.ts

@@ -22,6 +22,7 @@ export interface ObjectDefinitionOptions {
     constructorArgs?: any[];
     namespace?: string;
     srcPath?: string;
+    allowDowngrade?: boolean;
 }
 export interface TagPropsMetadata {
     key: string | number | symbol;

package/dist/util/camelCase.d.ts

@@ -0,0 +1,3 @@
+export declare function camelCase(input: string): string;
+export declare function pascalCase(input: string): string;
+//# sourceMappingURL=camelCase.d.ts.map

package/dist/util/camelCase.js

@@ -0,0 +1,88 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pascalCase = exports.camelCase = void 0;
+const UPPERCASE = /[\p{Lu}]/u;
+const LOWERCASE = /[\p{Ll}]/u;
+const IDENTIFIER = /([\p{Alpha}\p{N}_]|$)/u;
+const SEPARATORS = /[_.\- ]+/;
+const LEADING_SEPARATORS = new RegExp('^' + SEPARATORS.source);
+const SEPARATORS_AND_IDENTIFIER = new RegExp(SEPARATORS.source + IDENTIFIER.source, 'gu');
+const NUMBERS_AND_IDENTIFIER = new RegExp('\\d+' + IDENTIFIER.source, 'gu');
+const preserveCamelCase = (string, toLowerCase, toUpperCase) => {
+    let isLastCharLower = false;
+    let isLastCharUpper = false;
+    let isLastLastCharUpper = false;
+    for (let i = 0; i < string.length; i++) {
+        const character = string[i];
+        if (isLastCharLower && UPPERCASE.test(character)) {
+            string = string.slice(0, i) + '-' + string.slice(i);
+            isLastCharLower = false;
+            isLastLastCharUpper = isLastCharUpper;
+            isLastCharUpper = true;
+            i++;
+        }
+        else if (isLastCharUpper &&
+            isLastLastCharUpper &&
+            LOWERCASE.test(character)) {
+            string = string.slice(0, i - 1) + '-' + string.slice(i - 1);
+            isLastLastCharUpper = isLastCharUpper;
+            isLastCharUpper = false;
+            isLastCharLower = true;
+        }
+        else {
+            isLastCharLower =
+                toLowerCase(character) === character &&
+                    toUpperCase(character) !== character;
+            isLastLastCharUpper = isLastCharUpper;
+            isLastCharUpper =
+                toUpperCase(character) === character &&
+                    toLowerCase(character) !== character;
+        }
+    }
+    return string;
+};
+const postProcess = (input, toUpperCase) => {
+    SEPARATORS_AND_IDENTIFIER.lastIndex = 0;
+    NUMBERS_AND_IDENTIFIER.lastIndex = 0;
+    return input
+        .replace(SEPARATORS_AND_IDENTIFIER, (_, identifier) => toUpperCase(identifier))
+        .replace(NUMBERS_AND_IDENTIFIER, m => toUpperCase(m));
+};
+function camelCaseOrigin(input, options) {
+    options = {
+        pascalCase: false,
+        ...options,
+    };
+    input = input.trim();
+    if (input.length === 0) {
+        return '';
+    }
+    const toLowerCase = string => string.toLowerCase();
+    const toUpperCase = string => string.toUpperCase();
+    if (input.length === 1) {
+        return options.pascalCase ? toUpperCase(input) : toLowerCase(input);
+    }
+    const hasUpperCase = input !== toLowerCase(input);
+    if (hasUpperCase) {
+        input = preserveCamelCase(input, toLowerCase, toUpperCase);
+    }
+    input = input.replace(LEADING_SEPARATORS, '');
+    input = toLowerCase(input);
+    if (options.pascalCase) {
+        input = toUpperCase(input.charAt(0)) + input.slice(1);
+    }
+    return postProcess(input, toUpperCase);
+}
+function camelCase(input) {
+    return camelCaseOrigin(input, {
+        pascalCase: false,
+    });
+}
+exports.camelCase = camelCase;
+function pascalCase(input) {
+    return camelCaseOrigin(input, {
+        pascalCase: true,
+    });
+}
+exports.pascalCase = pascalCase;
+//# sourceMappingURL=camelCase.js.map

package/dist/util/format.d.ts

@@ -0,0 +1,25 @@
+export declare const FORMAT: {
+    MS: {
+        ONE_SECOND: number;
+        ONE_MINUTE: number;
+        ONE_HOUR: number;
+        ONE_DAY: number;
+        ONE_WEEK: number;
+        ONE_YEAR: number;
+    };
+    CRONTAB: {
+        EVERY_SECOND: string;
+        EVERY_MINUTE: string;
+        EVERY_HOUR: string;
+        EVERY_DAY: string;
+        EVERY_DAY_ZERO_FIFTEEN: string;
+        EVERY_DAY_ONE_FIFTEEN: string;
+        EVERY_PER_5_SECOND: string;
+        EVERY_PER_10_SECOND: string;
+        EVERY_PER_30_SECOND: string;
+        EVERY_PER_5_MINUTE: string;
+        EVERY_PER_10_MINUTE: string;
+        EVERY_PER_30_MINUTE: string;
+    };
+};
+//# sourceMappingURL=format.d.ts.map

package/dist/util/format.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FORMAT = void 0;
+// value from ms package
+const s = 1000;
+const m = s * 60;
+const h = m * 60;
+const d = h * 24;
+const w = d * 7;
+const y = d * 365.25;
+const MS = {
+    ONE_SECOND: s,
+    ONE_MINUTE: m,
+    ONE_HOUR: h,
+    ONE_DAY: d,
+    ONE_WEEK: w,
+    ONE_YEAR: y,
+};
+// crontab pre format
+const CRONTAB = {
+    EVERY_SECOND: '* * * * * *',
+    EVERY_MINUTE: '0 * * * * *',
+    EVERY_HOUR: '0 0 * * * *',
+    EVERY_DAY: '0 0 0 * * *',
+    EVERY_DAY_ZERO_FIFTEEN: '0 15 0 * * *',
+    EVERY_DAY_ONE_FIFTEEN: '0 15 1 * * *',
+    EVERY_PER_5_SECOND: '*/5 * * * * *',
+    EVERY_PER_10_SECOND: '*/10 * * * * *',
+    EVERY_PER_30_SECOND: '*/30 * * * * *',
+    EVERY_PER_5_MINUTE: '0 */5 * * * *',
+    EVERY_PER_10_MINUTE: '0 */10 * * * *',
+    EVERY_PER_30_MINUTE: '0 */30 * * * *',
+};
+exports.FORMAT = {
+    MS,
+    CRONTAB,
+};
+//# sourceMappingURL=format.js.map

package/dist/util/fs.d.ts

@@ -0,0 +1,5 @@
+export declare function exists(p: any): Promise<boolean>;
+export declare const FileUtils: {
+    exists: typeof exists;
+};
+//# sourceMappingURL=fs.d.ts.map

package/dist/util/fs.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FileUtils = exports.exists = void 0;
+const fs_1 = require("fs");
+async function exists(p) {
+    return fs_1.promises
+        .access(p, fs_1.constants.F_OK)
+        .then(() => true)
+        .catch(() => false);
+}
+exports.exists = exists;
+exports.FileUtils = {
+    exists,
+};
+//# sourceMappingURL=fs.js.map

package/dist/util/index.d.ts

@@ -1,9 +1,13 @@
+import { camelCase, pascalCase } from './camelCase';
+import { randomUUID } from './uuid';
+export declare function isString(value: any): boolean;
 export declare function isClass(fn: any): boolean;
 export declare function isAsyncFunction(value: any): boolean;
 export declare function isGeneratorFunction(value: any): boolean;
 export declare function isPromise(value: any): boolean;
 export declare function isFunction(value: any): boolean;
 export declare function isObject(value: any): boolean;
+export declare function isPlainObject(obj: any): any;
 export declare function isNumber(value: any): boolean;
 export declare function isProxy(value: any): boolean;
 export declare function isMap(value: any): boolean;
@@ -19,13 +23,37 @@ export declare function sleep(sleepTime?: number): Promise<void>;
  */
 export declare function getParamNames(func: any): string[];
 /**
- * 按照框架规则返回类名字
- * @param name 类名称
- */
-export declare function classNamed(name: string): string;
-/**
- * generate a lightweight random id, enough for ioc container
+ * generate a lightweight 32 bit random id, enough for ioc container
  */
 export declare function generateRandomId(): string;
 export declare function merge(target: any, src: any): any;
+export declare function toAsyncFunction<T extends (...args: any[]) => any>(method: T): (...args: Parameters<T>) => Promise<ReturnType<T>>;
+export declare const Types: {
+    isClass: typeof isClass;
+    isAsyncFunction: typeof isAsyncFunction;
+    isGeneratorFunction: typeof isGeneratorFunction;
+    isString: typeof isString;
+    isPromise: typeof isPromise;
+    isFunction: typeof isFunction;
+    isObject: typeof isObject;
+    isPlainObject: typeof isPlainObject;
+    isNumber: typeof isNumber;
+    isProxy: typeof isProxy;
+    isMap: typeof isMap;
+    isSet: typeof isSet;
+    isRegExp: typeof isRegExp;
+    isUndefined: typeof isUndefined;
+    isNull: typeof isNull;
+    isNullOrUndefined: typeof isNullOrUndefined;
+};
+export declare const Utils: {
+    sleep: typeof sleep;
+    getParamNames: typeof getParamNames;
+    generateRandomId: typeof generateRandomId;
+    merge: typeof merge;
+    camelCase: typeof camelCase;
+    pascalCase: typeof pascalCase;
+    randomUUID: typeof randomUUID;
+    toAsyncFunction: typeof toAsyncFunction;
+};
 //# sourceMappingURL=index.d.ts.map

package/dist/util/index.js

@@ -1,15 +1,22 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.merge = exports.generateRandomId = exports.classNamed = exports.getParamNames = exports.sleep = exports.isNullOrUndefined = exports.isNull = exports.isUndefined = exports.isRegExp = exports.isSet = exports.isMap = exports.isProxy = exports.isNumber = exports.isObject = exports.isFunction = exports.isPromise = exports.isGeneratorFunction = exports.isAsyncFunction = exports.isClass = void 0;
+exports.Utils = exports.Types = exports.toAsyncFunction = exports.merge = exports.generateRandomId = exports.getParamNames = exports.sleep = exports.isNullOrUndefined = exports.isNull = exports.isUndefined = exports.isRegExp = exports.isSet = exports.isMap = exports.isProxy = exports.isNumber = exports.isPlainObject = exports.isObject = exports.isFunction = exports.isPromise = exports.isGeneratorFunction = exports.isAsyncFunction = exports.isClass = exports.isString = void 0;
 const util = require("util");
-const camelcase = require("camelcase");
 const crypto = require("crypto");
+const camelCase_1 = require("./camelCase");
+const uuid_1 = require("./uuid");
 const ToString = Function.prototype.toString;
+const hasOwn = Object.prototype.hasOwnProperty;
+const toStr = Object.prototype.toString;
 function fnBody(fn) {
     return ToString.call(fn)
         .replace(/^[^{]*{\s*/, '')
         .replace(/\s*}[^}]*$/, '');
 }
+function isString(value) {
+    return typeof value === 'string';
+}
+exports.isString = isString;
 function isClass(fn) {
     if (typeof fn !== 'function') {
         return false;
@@ -43,6 +50,27 @@ function isObject(value) {
     return value !== null && typeof value === 'object';
 }
 exports.isObject = isObject;
+function isPlainObject(obj) {
+    if (!obj || toStr.call(obj) !== '[object Object]') {
+        return false;
+    }
+    const hasOwnConstructor = hasOwn.call(obj, 'constructor');
+    const hasIsPrototypeOf = obj.constructor &&
+        obj.constructor.prototype &&
+        hasOwn.call(obj.constructor.prototype, 'isPrototypeOf');
+    // Not own constructor property must be Object
+    if (obj.constructor && !hasOwnConstructor && !hasIsPrototypeOf) {
+        return false;
+    }
+    // Own properties are enumerated firstly, so to speed up,
+    // if last one is own, then all properties are own.
+    let key;
+    for (key in obj) {
+        /**/
+    }
+    return typeof key === 'undefined' || hasOwn.call(obj, key);
+}
+exports.isPlainObject = isPlainObject;
 function isNumber(value) {
     return typeof value === 'number';
 }
@@ -103,15 +131,7 @@ function getParamNames(func) {
 }
 exports.getParamNames = getParamNames;
 /**
- * 按照框架规则返回类名字
- * @param name 类名称
- */
-function classNamed(name) {
-    return camelcase(name);
-}
-exports.classNamed = classNamed;
-/**
- * generate a lightweight random id, enough for ioc container
+ * generate a lightweight 32 bit random id, enough for ioc container
  */
 function generateRandomId() {
     // => f9b327e70bbcf42494ccb28b2d98e00e
@@ -135,4 +155,43 @@ function merge(target, src) {
     throw new Error('can not merge meta that type of ' + typeof target);
 }
 exports.merge = merge;
+function toAsyncFunction(method) {
+    if (isAsyncFunction(method)) {
+        return method;
+    }
+    else {
+        return async function (...args) {
+            return Promise.resolve(method.call(this, ...args));
+        };
+    }
+}
+exports.toAsyncFunction = toAsyncFunction;
+exports.Types = {
+    isClass,
+    isAsyncFunction,
+    isGeneratorFunction,
+    isString,
+    isPromise,
+    isFunction,
+    isObject,
+    isPlainObject,
+    isNumber,
+    isProxy,
+    isMap,
+    isSet,
+    isRegExp,
+    isUndefined,
+    isNull,
+    isNullOrUndefined,
+};
+exports.Utils = {
+    sleep,
+    getParamNames,
+    generateRandomId,
+    merge,
+    camelCase: camelCase_1.camelCase,
+    pascalCase: camelCase_1.pascalCase,
+    randomUUID: uuid_1.randomUUID,
+    toAsyncFunction,
+};
 //# sourceMappingURL=index.js.map

package/dist/util/uuid.d.ts

@@ -0,0 +1,5 @@
+/**
+ * a easy uuid v4 generator
+ */
+export declare function randomUUID(): string;
+//# sourceMappingURL=uuid.d.ts.map

package/dist/util/uuid.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.randomUUID = void 0;
+const crypto = require("crypto");
+/**
+ * code fork from https://github.com/uuidjs/uuid/blob/main/src/stringify.js
+ */
+const rnds8Pool = new Uint8Array(256); // # of random values to pre-allocate
+let poolPtr = rnds8Pool.length;
+function rng() {
+    if (poolPtr > rnds8Pool.length - 16) {
+        crypto.randomFillSync(rnds8Pool);
+        poolPtr = 0;
+    }
+    return rnds8Pool.slice(poolPtr, (poolPtr += 16));
+}
+/**
+ * Convert array of 16 byte values to UUID string format of the form:
+ * XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX
+ */
+const byteToHex = [];
+for (let i = 0; i < 256; ++i) {
+    byteToHex.push((i + 0x100).toString(16).substr(1));
+}
+function unsafeStringify(arr, offset = 0) {
+    // Note: Be careful editing this code!  It's been tuned for performance
+    // and works in ways you may not expect. See https://github.com/uuidjs/uuid/pull/434
+    return (byteToHex[arr[offset + 0]] +
+        byteToHex[arr[offset + 1]] +
+        byteToHex[arr[offset + 2]] +
+        byteToHex[arr[offset + 3]] +
+        '-' +
+        byteToHex[arr[offset + 4]] +
+        byteToHex[arr[offset + 5]] +
+        '-' +
+        byteToHex[arr[offset + 6]] +
+        byteToHex[arr[offset + 7]] +
+        '-' +
+        byteToHex[arr[offset + 8]] +
+        byteToHex[arr[offset + 9]] +
+        '-' +
+        byteToHex[arr[offset + 10]] +
+        byteToHex[arr[offset + 11]] +
+        byteToHex[arr[offset + 12]] +
+        byteToHex[arr[offset + 13]] +
+        byteToHex[arr[offset + 14]] +
+        byteToHex[arr[offset + 15]]).toLowerCase();
+}
+/**
+ * a easy uuid v4 generator
+ */
+function randomUUID() {
+    // node > v14.17
+    if (crypto['randomUUID']) {
+        return crypto['randomUUID']();
+    }
+    const rnds = rng();
+    // Per 4.4, set bits for version and `clock_seq_hi_and_reserved`
+    rnds[6] = (rnds[6] & 0x0f) | 0x40;
+    rnds[8] = (rnds[8] & 0x3f) | 0x80;
+    return unsafeStringify(rnds);
+}
+exports.randomUUID = randomUUID;
+//# sourceMappingURL=uuid.js.map