@eggjs/tegg-common-util 4.0.0-beta.8 → 4.0.0-beta.9

package/dist/FSUtil.d.ts

@@ -0,0 +1,3 @@
+export declare class FSUtil {
+    static fileExists(filePath: string): Promise<boolean>;
+}

package/dist/FSUtil.js

@@ -0,0 +1,13 @@
+import fs from 'node:fs/promises';
+export class FSUtil {
+    static async fileExists(filePath) {
+        try {
+            await fs.access(filePath);
+        }
+        catch {
+            return false;
+        }
+        return true;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiRlNVdGlsLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vc3JjL0ZTVXRpbC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsTUFBTSxrQkFBa0IsQ0FBQztBQUVsQyxNQUFNLE9BQU8sTUFBTTtJQUNqQixNQUFNLENBQUMsS0FBSyxDQUFDLFVBQVUsQ0FBQyxRQUFnQjtRQUN0QyxJQUFJLENBQUM7WUFDSCxNQUFNLEVBQUUsQ0FBQyxNQUFNLENBQUMsUUFBUSxDQUFDLENBQUM7UUFDNUIsQ0FBQztRQUFDLE1BQU0sQ0FBQztZQUNQLE9BQU8sS0FBSyxDQUFDO1FBQ2YsQ0FBQztRQUNELE9BQU8sSUFBSSxDQUFDO0lBQ2QsQ0FBQztDQUNGIn0=

package/dist/Graph.d.ts

@@ -0,0 +1,66 @@
+import type { GraphNodeObj } from '@eggjs/tegg-types';
+declare const inspect: unique symbol;
+export interface EdgeMeta {
+    equal(meta: EdgeMeta): boolean;
+    toString(): string;
+}
+export declare class GraphNode<T extends GraphNodeObj, M extends EdgeMeta = EdgeMeta> {
+    val: T;
+    toNodeMap: Map<string, {
+        node: GraphNode<T, M>;
+        meta?: M;
+    }>;
+    fromNodeMap: Map<string, {
+        node: GraphNode<T, M>;
+        meta?: M;
+    }>;
+    constructor(val: T);
+    get id(): string;
+    addToVertex(node: GraphNode<T, M>, meta?: M): boolean;
+    addFromVertex(node: GraphNode<T, M>, meta?: M): boolean;
+    [inspect](): {
+        val: T;
+        toNodes: {
+            node: GraphNode<T, M>;
+            meta?: M;
+        }[];
+        fromNodes: {
+            node: GraphNode<T, M>;
+            meta?: M;
+        }[];
+    };
+    toJSON(): {
+        val: T;
+        toNodes: {
+            node: GraphNode<T, M>;
+            meta?: M;
+        }[];
+        fromNodes: {
+            node: GraphNode<T, M>;
+            meta?: M;
+        }[];
+    };
+    toString(): string;
+}
+export declare class GraphPath<T extends GraphNodeObj, M extends EdgeMeta = EdgeMeta> {
+    nodeIdMap: Map<string, number>;
+    nodes: Array<{
+        node: GraphNode<T, M>;
+        meta?: M;
+    }>;
+    pushVertex(node: GraphNode<T, M>, meta?: M): boolean;
+    popVertex(): void;
+    toString(): string;
+    [inspect](): string;
+}
+export declare class Graph<T extends GraphNodeObj, M extends EdgeMeta = EdgeMeta> {
+    nodes: Map<string, GraphNode<T, M>>;
+    addVertex(node: GraphNode<T, M>): boolean;
+    addEdge(from: GraphNode<T, M>, to: GraphNode<T, M>, meta?: M): boolean;
+    findToNode(id: string, meta: M): GraphNode<T, M> | undefined;
+    appendVertexToPath(node: GraphNode<T, M>, accessPath: GraphPath<T, M>, meta?: M): boolean;
+    loopPath(): GraphPath<T, M> | undefined;
+    accessNode(node: GraphNode<T, M>, nodes: Array<GraphNode<T, M>>, accessed: boolean[], res: Array<GraphNode<T, M>>): void;
+    sort(): Array<GraphNode<T, M>>;
+}
+export {};

package/dist/Graph.js

@@ -0,0 +1,159 @@
+const inspect = Symbol.for('nodejs.util.inspect.custom');
+export class GraphNode {
+    val;
+    toNodeMap = new Map();
+    fromNodeMap = new Map();
+    constructor(val) {
+        this.val = val;
+    }
+    get id() {
+        return this.val.id;
+    }
+    addToVertex(node, meta) {
+        if (this.toNodeMap.has(node.id)) {
+            return false;
+        }
+        this.toNodeMap.set(node.id, { node, meta });
+        return true;
+    }
+    addFromVertex(node, meta) {
+        if (this.fromNodeMap.has(node.id)) {
+            return false;
+        }
+        this.fromNodeMap.set(node.id, { node, meta });
+        return true;
+    }
+    [inspect]() {
+        return this.toJSON();
+    }
+    toJSON() {
+        return {
+            val: this.val,
+            toNodes: Array.from(this.toNodeMap.values()),
+            fromNodes: Array.from(this.fromNodeMap.values()),
+        };
+    }
+    toString() {
+        return this.val.toString();
+    }
+}
+export class GraphPath {
+    nodeIdMap = new Map();
+    nodes = [];
+    pushVertex(node, meta) {
+        const val = this.nodeIdMap.get(node.id) || 0;
+        this.nodeIdMap.set(node.id, val + 1);
+        this.nodes.push({ node, meta });
+        return val === 0;
+    }
+    popVertex() {
+        const nodeHandler = this.nodes.pop();
+        if (nodeHandler) {
+            const val = this.nodeIdMap.get(nodeHandler.node.id);
+            this.nodeIdMap.set(nodeHandler.node.id, val - 1);
+        }
+    }
+    toString() {
+        const res = this.nodes.reduce((p, c) => {
+            let msg = '';
+            if (c.meta) {
+                msg += ` ${c.meta.toString()} -> `;
+            }
+            else if (p.length) {
+                msg += ' -> ';
+            }
+            msg += c.node.val.toString();
+            p.push(msg);
+            return p;
+        }, new Array());
+        return res.join('');
+    }
+    [inspect]() {
+        return this.toString();
+    }
+}
+export class Graph {
+    nodes = new Map();
+    addVertex(node) {
+        if (this.nodes.has(node.id)) {
+            return false;
+        }
+        this.nodes.set(node.id, node);
+        return true;
+    }
+    addEdge(from, to, meta) {
+        to.addFromVertex(from, meta);
+        return from.addToVertex(to, meta);
+    }
+    findToNode(id, meta) {
+        const node = this.nodes.get(id);
+        if (!node)
+            return undefined;
+        for (const { node: toNode, meta: edgeMeta } of node.toNodeMap.values()) {
+            if (edgeMeta && meta.equal(edgeMeta)) {
+                return toNode;
+            }
+        }
+        return undefined;
+    }
+    appendVertexToPath(node, accessPath, meta) {
+        if (!accessPath.pushVertex(node, meta)) {
+            return false;
+        }
+        for (const toNode of node.toNodeMap.values()) {
+            if (!this.appendVertexToPath(toNode.node, accessPath, toNode.meta)) {
+                return false;
+            }
+        }
+        accessPath.popVertex();
+        return true;
+    }
+    loopPath() {
+        const accessPath = new GraphPath();
+        const nodes = Array.from(this.nodes.values());
+        for (const node of nodes) {
+            if (!this.appendVertexToPath(node, accessPath)) {
+                return accessPath;
+            }
+        }
+        return;
+    }
+    accessNode(node, nodes, accessed, res) {
+        const index = nodes.indexOf(node);
+        if (accessed[index]) {
+            return;
+        }
+        if (!node.toNodeMap.size) {
+            accessed[nodes.indexOf(node)] = true;
+            res.push(node);
+            return;
+        }
+        for (const toNode of node.toNodeMap.values()) {
+            this.accessNode(toNode.node, nodes, accessed, res);
+        }
+        accessed[nodes.indexOf(node)] = true;
+        res.push(node);
+    }
+    // sort by direct
+    // priority:
+    // 1. vertex can not be access
+    // 2. reverse by access direct
+    //
+    // notice:
+    // 1. sort result is not stable
+    // 2. graph with loop can not be sort
+    sort() {
+        const res = [];
+        const nodes = Array.from(this.nodes.values());
+        const accessed = [];
+        for (let i = 0; i < nodes.length; ++i) {
+            accessed.push(false);
+        }
+        for (let i = 0; i < nodes.length; ++i) {
+            const node = nodes[i];
+            this.accessNode(node, nodes, accessed, res);
+        }
+        return res;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/MapUtil.d.ts

@@ -0,0 +1,3 @@
+export declare class MapUtil {
+    static getOrStore<K, V>(map: Map<K, V>, key: K, value: V): V;
+}

package/dist/MapUtil.js

@@ -0,0 +1,9 @@
+export class MapUtil {
+    static getOrStore(map, key, value) {
+        if (!map.has(key)) {
+            map.set(key, value);
+        }
+        return map.get(key);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiTWFwVXRpbC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3NyYy9NYXBVdGlsLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE1BQU0sT0FBTyxPQUFPO0lBQ2xCLE1BQU0sQ0FBQyxVQUFVLENBQU8sR0FBYyxFQUFFLEdBQU0sRUFBRSxLQUFRO1FBQ3RELElBQUksQ0FBQyxHQUFHLENBQUMsR0FBRyxDQUFDLEdBQUcsQ0FBQyxFQUFFLENBQUM7WUFDbEIsR0FBRyxDQUFDLEdBQUcsQ0FBQyxHQUFHLEVBQUUsS0FBSyxDQUFDLENBQUM7UUFDdEIsQ0FBQztRQUNELE9BQU8sR0FBRyxDQUFDLEdBQUcsQ0FBQyxHQUFHLENBQUUsQ0FBQztJQUN2QixDQUFDO0NBQ0YifQ==

package/dist/ModuleConfig.d.ts

@@ -0,0 +1,20 @@
+import type { InlineModuleReferenceConfig, ModuleConfig, ModuleReference, ModuleReferenceConfig, NpmModuleReferenceConfig, ReadModuleReferenceOptions } from '@eggjs/tegg-types';
+export declare class ModuleReferenceConfigHelp {
+    static isInlineModuleReference(moduleReference: ModuleReferenceConfig): moduleReference is InlineModuleReferenceConfig;
+    static isNpmModuleReference(moduleReference: ModuleReferenceConfig): moduleReference is NpmModuleReferenceConfig;
+}
+export declare class ModuleConfigUtil {
+    #private;
+    static configNames: string[] | undefined;
+    static setConfigNames(configNames: string[] | undefined): void;
+    static readModuleReference(baseDir: string, options?: ReadModuleReferenceOptions): readonly ModuleReference[];
+    private static readModuleReferenceFromModuleJson;
+    private static readModuleReferenceFromScan;
+    static readModuleFromNodeModules(baseDir: string): ModuleReference[];
+    static resolveModuleDir(moduleDir: string, baseDir?: string): string;
+    private static getModuleName;
+    static readModuleName(baseDir: string, moduleDir: string): Promise<string>;
+    static readModuleNameSync(moduleDir: string, baseDir?: string): string;
+    static loadModuleConfig(moduleDir: string, baseDir?: string, env?: string): Promise<ModuleConfig>;
+    static loadModuleConfigSync(moduleDir: string, baseDir?: string, env?: string): ModuleConfig;
+}

package/dist/ModuleConfig.js

@@ -0,0 +1,282 @@
+import assert from 'node:assert';
+import fs, { promises as fsPromise } from 'node:fs';
+import path from 'node:path';
+import { extend } from 'extend2';
+import { globbySync } from 'globby';
+import { load as yamlLoad } from 'js-yaml';
+import { importResolve } from '@eggjs/utils';
+import { FSUtil } from "./FSUtil.js";
+export class ModuleReferenceConfigHelp {
+    static isInlineModuleReference(moduleReference) {
+        return !!moduleReference.path;
+    }
+    static isNpmModuleReference(moduleReference) {
+        return !!moduleReference.package;
+    }
+}
+const DEFAULT_READ_MODULE_REF_OPTS = {
+    deep: 10,
+};
+export class ModuleConfigUtil {
+    static configNames;
+    static setConfigNames(configNames) {
+        ModuleConfigUtil.configNames = configNames;
+    }
+    static readModuleReference(baseDir, options) {
+        // 1. module.json exits use module.json as module reference
+        // 1. module.json not exits scan baseDir get package.json to find modules
+        const configDir = path.join(baseDir, 'config');
+        const moduleJsonPath = path.join(configDir, 'module.json');
+        if (fs.existsSync(moduleJsonPath)) {
+            return this.readModuleReferenceFromModuleJson(configDir, moduleJsonPath, options?.cwd || baseDir);
+        }
+        return this.readModuleReferenceFromScan(baseDir, options);
+    }
+    static readModuleReferenceFromModuleJson(configDir, moduleJsonPath, cwd) {
+        const moduleJsonContent = fs.readFileSync(moduleJsonPath, 'utf8');
+        const moduleJson = JSON.parse(moduleJsonContent);
+        const moduleReferenceList = [];
+        for (const moduleReferenceConfig of moduleJson) {
+            let moduleReference;
+            if (ModuleReferenceConfigHelp.isNpmModuleReference(moduleReferenceConfig)) {
+                const options = cwd ? { paths: [cwd] } : {};
+                // path.posix for windows keep path as foo/package.json
+                const pkgJson = path.posix.join(moduleReferenceConfig.package, 'package.json');
+                const file = importResolve(pkgJson, options);
+                const modulePath = path.dirname(file);
+                moduleReference = {
+                    path: modulePath,
+                    name: ModuleConfigUtil.readModuleNameSync(modulePath),
+                };
+            }
+            else if (ModuleReferenceConfigHelp.isInlineModuleReference(moduleReferenceConfig)) {
+                const modulePath = path.join(configDir, moduleReferenceConfig.path);
+                moduleReference = {
+                    path: modulePath,
+                    name: ModuleConfigUtil.readModuleNameSync(modulePath),
+                };
+            }
+            else {
+                throw new Error('unknown type of module reference config: ' + JSON.stringify(moduleReferenceConfig));
+            }
+            moduleReferenceList.push(moduleReference);
+        }
+        return moduleReferenceList;
+    }
+    static readModuleReferenceFromScan(baseDir, options) {
+        const ref = [];
+        const realOptions = Object.assign({}, DEFAULT_READ_MODULE_REF_OPTS, options);
+        const packagePaths = globbySync([
+            '**/package.json',
+            // not load node_modules
+            '!**/node_modules',
+            // not load files in .xxx/
+            '!**/+(.*)/**',
+            // not load coverage
+            '!**/coverage',
+            ...(realOptions.extraFilePattern || []),
+        ], {
+            cwd: baseDir,
+            deep: realOptions.deep,
+        });
+        const moduleDirSet = new Set();
+        for (const packagePath of packagePaths) {
+            const absolutePkgPath = path.join(baseDir, packagePath);
+            let realPkgPath;
+            try {
+                realPkgPath = fs.realpathSync(absolutePkgPath);
+            }
+            catch {
+                continue;
+            }
+            const moduleDir = path.dirname(realPkgPath);
+            // skip the symbolic link
+            if (moduleDirSet.has(moduleDir)) {
+                continue;
+            }
+            moduleDirSet.add(moduleDir);
+            let name;
+            try {
+                name = this.readModuleNameSync(moduleDir);
+            }
+            catch {
+                continue;
+            }
+            ref.push({
+                path: moduleDir,
+                name,
+            });
+        }
+        const moduleReferences = this.readModuleFromNodeModules(baseDir);
+        for (const moduleReference of moduleReferences) {
+            const moduleBasePath = path.basename(moduleReference.path);
+            moduleDirSet.forEach(modulePath => {
+                if (path.basename(modulePath) === moduleBasePath) {
+                    throw new Error('duplicate import of module reference: ' + moduleBasePath);
+                }
+            });
+            ref.push({
+                path: moduleReference.path,
+                name: moduleReference.name,
+            });
+        }
+        return ref;
+    }
+    static readModuleFromNodeModules(baseDir) {
+        const ref = [];
+        let pkgContent;
+        try {
+            pkgContent = fs.readFileSync(path.join(baseDir, 'package.json'), 'utf8');
+        }
+        catch {
+            return [];
+        }
+        const pkg = JSON.parse(pkgContent);
+        for (const dependencyKey of Object.keys(pkg.dependencies || {})) {
+            let packageJsonPath;
+            try {
+                // https://nodejs.org/api/packages.html#package-entry-points
+                // ignore cases where the package entry is exports but package.json is not exported
+                packageJsonPath = importResolve(`${dependencyKey}/package.json`, { paths: [baseDir] });
+            }
+            catch {
+                continue;
+            }
+            const absolutePkgPath = path.dirname(packageJsonPath);
+            const realPkgPath = fs.realpathSync(absolutePkgPath);
+            try {
+                const name = this.readModuleNameSync(realPkgPath);
+                ref.push({
+                    path: realPkgPath,
+                    name,
+                });
+            }
+            catch {
+                continue;
+            }
+        }
+        return ref;
+    }
+    static resolveModuleDir(moduleDir, baseDir) {
+        if (path.isAbsolute(moduleDir)) {
+            return moduleDir;
+        }
+        assert(baseDir, 'baseDir is required');
+        return path.join(baseDir, 'config', moduleDir);
+    }
+    static getModuleName(pkg) {
+        assert(pkg.eggModule && pkg.eggModule.name, 'eggModule.name not found in package.json');
+        return pkg.eggModule.name;
+    }
+    static async readModuleName(baseDir, moduleDir) {
+        moduleDir = ModuleConfigUtil.resolveModuleDir(moduleDir, baseDir);
+        const pkgContent = await fsPromise.readFile(path.join(moduleDir, 'package.json'), 'utf8');
+        const pkg = JSON.parse(pkgContent);
+        return ModuleConfigUtil.getModuleName(pkg);
+    }
+    static readModuleNameSync(moduleDir, baseDir) {
+        moduleDir = ModuleConfigUtil.resolveModuleDir(moduleDir, baseDir);
+        const pkgContent = fs.readFileSync(path.join(moduleDir, 'package.json'), 'utf8');
+        const pkg = JSON.parse(pkgContent);
+        return ModuleConfigUtil.getModuleName(pkg);
+    }
+    static async loadModuleConfig(moduleDir, baseDir, env) {
+        const modulePath = ModuleConfigUtil.resolveModuleDir(moduleDir, baseDir);
+        let configNames;
+        if (env) {
+            configNames = ['module', `module.${env}`];
+        }
+        else {
+            // assert(ModuleConfigUtil.configNames, 'should setConfigNames before load module config');
+            configNames = ModuleConfigUtil.configNames || ['module'];
+        }
+        const target = {};
+        for (const configName of configNames) {
+            let config = await ModuleConfigUtil.#loadOne(modulePath, configName);
+            // both module.yml and module.default.yml are ok for default config
+            if (configName === 'module.default' && !config) {
+                config = await ModuleConfigUtil.#loadOne(modulePath, 'module');
+            }
+            if (config) {
+                extend(true, target, config);
+            }
+        }
+        return target;
+    }
+    static async #loadOne(moduleDir, configName) {
+        const yamlConfigPath = path.join(moduleDir, `${configName}.yml`);
+        let config = await ModuleConfigUtil.#loadYaml(yamlConfigPath);
+        if (!config) {
+            const jsonConfigPath = path.join(moduleDir, `${configName}.json`);
+            config = await ModuleConfigUtil.#loadJson(jsonConfigPath);
+        }
+        return config;
+    }
+    static async #loadJson(moduleJsonPath) {
+        const moduleJsonPathExists = await FSUtil.fileExists(moduleJsonPath);
+        if (!moduleJsonPathExists) {
+            return;
+        }
+        const moduleJsonContent = await fsPromise.readFile(moduleJsonPath, 'utf8');
+        const moduleJson = JSON.parse(moduleJsonContent);
+        return moduleJson.config;
+    }
+    static async #loadYaml(moduleYamlPath) {
+        const moduleYamlPathExists = await FSUtil.fileExists(moduleYamlPath);
+        if (!moduleYamlPathExists) {
+            return;
+        }
+        const moduleYamlContent = await fsPromise.readFile(moduleYamlPath, 'utf8');
+        return yamlLoad(moduleYamlContent);
+    }
+    static loadModuleConfigSync(moduleDir, baseDir, env) {
+        const modulePath = ModuleConfigUtil.resolveModuleDir(moduleDir, baseDir);
+        let configNames;
+        if (env) {
+            configNames = ['module', `module.${env}`];
+        }
+        else {
+            // assert(ModuleConfigUtil.configNames, 'should setConfigNames before load module config');
+            configNames = ModuleConfigUtil.configNames || ['module'];
+        }
+        const target = {};
+        for (const configName of configNames) {
+            let config = ModuleConfigUtil.#loadOneSync(modulePath, configName);
+            // both module.yml and module.default.yml are ok for default config
+            if (configName === 'module.default' && !config) {
+                config = ModuleConfigUtil.#loadOneSync(modulePath, 'module');
+            }
+            if (config) {
+                extend(true, target, config);
+            }
+        }
+        return target;
+    }
+    static #loadOneSync(moduleDir, configName) {
+        const yamlConfigPath = path.join(moduleDir, `${configName}.yml`);
+        let config = ModuleConfigUtil.#loadYamlSync(yamlConfigPath);
+        if (!config) {
+            const jsonConfigPath = path.join(moduleDir, `${configName}.json`);
+            config = ModuleConfigUtil.#loadJsonSync(jsonConfigPath);
+        }
+        return config;
+    }
+    static #loadJsonSync(moduleJsonPath) {
+        const moduleJsonPathExists = fs.existsSync(moduleJsonPath);
+        if (!moduleJsonPathExists) {
+            return;
+        }
+        const moduleJsonContent = fs.readFileSync(moduleJsonPath, 'utf8');
+        const moduleJson = JSON.parse(moduleJsonContent);
+        return moduleJson.config;
+    }
+    static #loadYamlSync(moduleYamlPath) {
+        const moduleYamlPathExists = fs.existsSync(moduleYamlPath);
+        if (!moduleYamlPathExists) {
+            return;
+        }
+        const moduleYamlContent = fs.readFileSync(moduleYamlPath, 'utf8');
+        return yamlLoad(moduleYamlContent);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ModuleConfig.js","sourceRoot":"","sources":["../src/ModuleConfig.ts"],"names":[],"mappings":"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"}

package/dist/ModuleConfigs.d.ts

@@ -0,0 +1,7 @@
+import type { ModuleConfig, ModuleConfigHolder } from '@eggjs/tegg-types';
+export declare class ModuleConfigs {
+    readonly inner: Record<string, ModuleConfigHolder>;
+    constructor(inner: Record<string, ModuleConfigHolder>);
+    get(moduleName: string): ModuleConfig | undefined;
+}
+export type { ModuleConfig };

package/dist/ModuleConfigs.js

@@ -0,0 +1,10 @@
+export class ModuleConfigs {
+    inner;
+    constructor(inner) {
+        this.inner = inner;
+    }
+    get(moduleName) {
+        return this.inner[moduleName]?.config;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiTW9kdWxlQ29uZmlncy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3NyYy9Nb2R1bGVDb25maWdzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUVBLE1BQU0sT0FBTyxhQUFhO0lBQ2YsS0FBSyxDQUFxQztJQUVuRCxZQUFZLEtBQXlDO1FBQ25ELElBQUksQ0FBQyxLQUFLLEdBQUcsS0FBSyxDQUFDO0lBQ3JCLENBQUM7SUFFRCxHQUFHLENBQUMsVUFBa0I7UUFDcEIsT0FBTyxJQUFJLENBQUMsS0FBSyxDQUFDLFVBQVUsQ0FBQyxFQUFFLE1BQU0sQ0FBQztJQUN4QyxDQUFDO0NBQ0YifQ==

package/dist/NameUtil.d.ts

@@ -0,0 +1,3 @@
+export declare class NameUtil {
+    static getClassName(constructor: Function): string;
+}

package/dist/NameUtil.js

@@ -0,0 +1,6 @@
+export class NameUtil {
+    static getClassName(constructor) {
+        return constructor.name[0].toLowerCase() + constructor.name.substring(1);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiTmFtZVV0aWwuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9zcmMvTmFtZVV0aWwudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsTUFBTSxPQUFPLFFBQVE7SUFDbkIsTUFBTSxDQUFDLFlBQVksQ0FBQyxXQUFxQjtRQUN2QyxPQUFPLFdBQVcsQ0FBQyxJQUFJLENBQUMsQ0FBQyxDQUFDLENBQUMsV0FBVyxFQUFFLEdBQUcsV0FBVyxDQUFDLElBQUksQ0FBQyxTQUFTLENBQUMsQ0FBQyxDQUFDLENBQUM7SUFDM0UsQ0FBQztDQUNGIn0=

package/dist/ObjectUtils.d.ts

@@ -0,0 +1,6 @@
+import type { EggProtoImplClass } from '@eggjs/tegg-types';
+export declare class ObjectUtils {
+    static getProperties(obj: object): string[];
+    static getFunctionArgNameList(func: Function): string[];
+    static getConstructorArgNameList(clazz: EggProtoImplClass): string[];
+}