@riktajs/core 0.9.0 → 0.10.1

package/dist/core/container/abstract-class.utils.js

@@ -1,27 +1,17 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.PRIMARY_METADATA = exports.IMPLEMENTS_METADATA = void 0;
-exports.isAbstractClass = isAbstractClass;
-exports.extendsFrom = extendsFrom;
-exports.getImplementedAbstract = getImplementedAbstract;
-exports.isPrimaryImplementation = isPrimaryImplementation;
-exports.setImplementsMetadata = setImplementsMetadata;
-exports.setPrimaryMetadata = setPrimaryMetadata;
-exports.markAsAbstract = markAsAbstract;
-exports.IMPLEMENTS_METADATA = Symbol('rikta:implements');
-exports.PRIMARY_METADATA = Symbol('rikta:primary');
-function isAbstractClass(target) {
+export const IMPLEMENTS_METADATA = Symbol('rikta:implements');
+export const PRIMARY_METADATA = Symbol('rikta:primary');
+export function isAbstractClass(target) {
     if (typeof target !== 'function') {
         return false;
     }
-    const isMarkedAbstract = Reflect.getMetadata(exports.IMPLEMENTS_METADATA, target) === undefined
+    const isMarkedAbstract = Reflect.getMetadata(IMPLEMENTS_METADATA, target) === undefined
         && Reflect.hasMetadata('abstract:class', target);
     if (isMarkedAbstract) {
         return true;
     }
     return Reflect.getMetadata('abstract:class', target) === true;
 }
-function extendsFrom(derived, base) {
+export function extendsFrom(derived, base) {
     if (!derived || !base) {
         return false;
     }
@@ -37,18 +27,18 @@ function extendsFrom(derived, base) {
     }
     return false;
 }
-function getImplementedAbstract(target) {
-    return Reflect.getMetadata(exports.IMPLEMENTS_METADATA, target);
+export function getImplementedAbstract(target) {
+    return Reflect.getMetadata(IMPLEMENTS_METADATA, target);
 }
-function isPrimaryImplementation(target) {
-    return Reflect.getMetadata(exports.PRIMARY_METADATA, target) === true;
+export function isPrimaryImplementation(target) {
+    return Reflect.getMetadata(PRIMARY_METADATA, target) === true;
 }
-function setImplementsMetadata(target, abstractClass) {
-    Reflect.defineMetadata(exports.IMPLEMENTS_METADATA, abstractClass, target);
+export function setImplementsMetadata(target, abstractClass) {
+    Reflect.defineMetadata(IMPLEMENTS_METADATA, abstractClass, target);
 }
-function setPrimaryMetadata(target) {
-    Reflect.defineMetadata(exports.PRIMARY_METADATA, true, target);
+export function setPrimaryMetadata(target) {
+    Reflect.defineMetadata(PRIMARY_METADATA, true, target);
 }
-function markAsAbstract(target) {
+export function markAsAbstract(target) {
     Reflect.defineMetadata('abstract:class', true, target);
 }

package/dist/core/container/container.d.ts

@@ -1,6 +1,6 @@
 import 'reflect-metadata';
-import { Constructor, InjectableOptions } from '../types';
-import { Token, ProviderDefinition } from './injection-token';
+import { Constructor, InjectableOptions } from '../types.js';
+import { Token, ProviderDefinition } from './injection-token.js';
 export declare class Container {
     private static instance;
     private singletons;

package/dist/core/container/container.js

@@ -1,13 +1,10 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.container = exports.Container = void 0;
-require("reflect-metadata");
-const constants_1 = require("../constants");
-const injection_token_1 = require("./injection-token");
-const registry_1 = require("../registry");
-const abstract_class_utils_1 = require("./abstract-class.utils");
-const request_scope_1 = require("./request-scope");
-class Container {
+import 'reflect-metadata';
+import { INJECT_METADATA, AUTOWIRED_METADATA } from '../constants.js';
+import { InjectionToken } from './injection-token.js';
+import { registry } from '../registry.js';
+import { isAbstractClass } from './abstract-class.utils.js';
+import { requestScopeStorage } from './request-scope.js';
+export class Container {
     static instance;
     singletons = new Map();
     providers = new Map();
@@ -80,7 +77,7 @@ class Container {
                     this.singletons.set(token, instance);
                     return instance;
                 }
-                if (!(0, abstract_class_utils_1.isAbstractClass)(token)) {
+                if (!isAbstractClass(token)) {
                     return this.resolveClass(token);
                 }
             }
@@ -102,7 +99,7 @@ class Container {
         if (config?.provider && 'useClass' in config.provider) {
             return config.provider.useClass;
         }
-        const implementations = registry_1.registry.getImplementations(abstractClass);
+        const implementations = registry.getImplementations(abstractClass);
         if (!implementations || implementations.length === 0) {
             return undefined;
         }
@@ -168,18 +165,18 @@ class Container {
             return this.singletons.get(target);
         }
         if (scope === 'request') {
-            if (!request_scope_1.requestScopeStorage.isInRequestScope()) {
+            if (!requestScopeStorage.isInRequestScope()) {
                 throw new Error(`Cannot resolve request-scoped provider '${target.name}' outside of a request context. ` +
                     `Request-scoped providers can only be resolved during HTTP request handling.`);
             }
-            const existingInstance = request_scope_1.requestScopeStorage.get(target);
+            const existingInstance = requestScopeStorage.get(target);
             if (existingInstance !== undefined) {
                 return existingInstance;
             }
         }
         this.resolutionStack.add(target);
         try {
-            const injectMeta = Reflect.getMetadata(constants_1.INJECT_METADATA, target) ?? [];
+            const injectMeta = Reflect.getMetadata(INJECT_METADATA, target) ?? [];
             const paramTypes = Reflect.getMetadata('design:paramtypes', target) ?? [];
             const maxIndex = injectMeta.length > 0
                 ? Math.max(...injectMeta.map(m => m.index ?? -1))
@@ -218,7 +215,7 @@ class Container {
                 this.singletons.set(target, instance);
             }
             else if (scope === 'request') {
-                request_scope_1.requestScopeStorage.set(target, instance);
+                requestScopeStorage.set(target, instance);
             }
             return instance;
         }
@@ -227,7 +224,7 @@ class Container {
         }
     }
     injectProperties(target, instance) {
-        const autowireMeta = Reflect.getMetadata(constants_1.AUTOWIRED_METADATA, target) ?? [];
+        const autowireMeta = Reflect.getMetadata(AUTOWIRED_METADATA, target) ?? [];
         for (const meta of autowireMeta) {
             if (!meta.propertyKey)
                 continue;
@@ -283,7 +280,7 @@ class Container {
         if (typeof token === 'function') {
             return token.name;
         }
-        if (token instanceof injection_token_1.InjectionToken) {
+        if (token instanceof InjectionToken) {
             return token.toString();
         }
         if (typeof token === 'symbol') {
@@ -292,5 +289,4 @@ class Container {
         return String(token);
     }
 }
-exports.Container = Container;
-exports.container = Container.getInstance();
+export const container = Container.getInstance();

package/dist/core/container/implements.decorator.d.ts

@@ -1,5 +1,5 @@
 import 'reflect-metadata';
-import { AnyConstructor } from '../types';
+import { AnyConstructor } from '../types.js';
 export declare function Implements<T extends AnyConstructor>(abstractClass: T): ClassDecorator;
 export declare function Primary(): ClassDecorator;
 export declare function Named(name: string): ClassDecorator;

package/dist/core/container/implements.decorator.js

@@ -1,45 +1,39 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Implements = Implements;
-exports.Primary = Primary;
-exports.Named = Named;
-exports.AbstractClass = AbstractClass;
-require("reflect-metadata");
-const abstract_class_utils_1 = require("./abstract-class.utils");
-const registry_1 = require("../registry");
-function Implements(abstractClass) {
+import 'reflect-metadata';
+import { setImplementsMetadata, setPrimaryMetadata, markAsAbstract, IMPLEMENTS_METADATA } from './abstract-class.utils.js';
+import { registry } from '../registry.js';
+export function Implements(abstractClass) {
     return (target) => {
-        (0, abstract_class_utils_1.setImplementsMetadata)(target, abstractClass);
-        (0, abstract_class_utils_1.markAsAbstract)(abstractClass);
+        setImplementsMetadata(target, abstractClass);
+        markAsAbstract(abstractClass);
         const name = Reflect.getMetadata('rikta:named', target);
-        registry_1.registry.registerAbstractImplementation(abstractClass, target, name);
+        registry.registerAbstractImplementation(abstractClass, target, name);
         const isPrimary = Reflect.getMetadata('rikta:is-primary', target) === true;
         if (isPrimary) {
-            registry_1.registry.setPrimaryImplementation(abstractClass, target);
+            registry.setPrimaryImplementation(abstractClass, target);
         }
     };
 }
-function Primary() {
+export function Primary() {
     return (target) => {
-        (0, abstract_class_utils_1.setPrimaryMetadata)(target);
-        const abstractClass = Reflect.getMetadata(abstract_class_utils_1.IMPLEMENTS_METADATA, target);
+        setPrimaryMetadata(target);
+        const abstractClass = Reflect.getMetadata(IMPLEMENTS_METADATA, target);
         if (abstractClass) {
-            registry_1.registry.setPrimaryImplementation(abstractClass, target);
+            registry.setPrimaryImplementation(abstractClass, target);
         }
         Reflect.defineMetadata('rikta:is-primary', true, target);
     };
 }
-function Named(name) {
+export function Named(name) {
     return (target) => {
         Reflect.defineMetadata('rikta:named', name, target);
-        const abstractClass = Reflect.getMetadata(abstract_class_utils_1.IMPLEMENTS_METADATA, target);
+        const abstractClass = Reflect.getMetadata(IMPLEMENTS_METADATA, target);
         if (abstractClass) {
-            registry_1.registry.setImplementationName(abstractClass, target, name);
+            registry.setImplementationName(abstractClass, target, name);
         }
     };
 }
-function AbstractClass() {
+export function AbstractClass() {
     return (target) => {
-        (0, abstract_class_utils_1.markAsAbstract)(target);
+        markAsAbstract(target);
     };
 }

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

@@ -1,5 +1,5 @@
-export * from './container';
-export * from './injection-token';
-export * from './abstract-class.utils';
-export * from './implements.decorator';
-export * from './request-scope';
+export * from './container.js';
+export * from './injection-token.js';
+export * from './abstract-class.utils.js';
+export * from './implements.decorator.js';
+export * from './request-scope.js';

package/dist/core/container/index.js

@@ -1,21 +1,5 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-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 });
-__exportStar(require("./container"), exports);
-__exportStar(require("./injection-token"), exports);
-__exportStar(require("./abstract-class.utils"), exports);
-__exportStar(require("./implements.decorator"), exports);
-__exportStar(require("./request-scope"), exports);
+export * from './container.js';
+export * from './injection-token.js';
+export * from './abstract-class.utils.js';
+export * from './implements.decorator.js';
+export * from './request-scope.js';

package/dist/core/container/injection-token.js

@@ -1,7 +1,4 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.InjectionToken = void 0;
-class InjectionToken {
+export class InjectionToken {
     description;
     options;
     constructor(description, options) {
@@ -12,4 +9,3 @@ class InjectionToken {
         return `InjectionToken(${this.description})`;
     }
 }
-exports.InjectionToken = InjectionToken;

package/dist/core/container/request-scope.d.ts

@@ -1,4 +1,4 @@
-import { Token } from './injection-token';
+import { Token } from './injection-token.js';
 export declare class RequestScopeStorage {
     private static instance;
     private readonly asyncLocalStorage;

package/dist/core/container/request-scope.js

@@ -1,10 +1,7 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.requestScopeStorage = exports.RequestScopeStorage = void 0;
-const node_async_hooks_1 = require("node:async_hooks");
-class RequestScopeStorage {
+import { AsyncLocalStorage } from 'node:async_hooks';
+export class RequestScopeStorage {
     static instance;
-    asyncLocalStorage = new node_async_hooks_1.AsyncLocalStorage();
+    asyncLocalStorage = new AsyncLocalStorage();
     constructor() { }
     static getInstance() {
         if (!RequestScopeStorage.instance) {
@@ -49,5 +46,4 @@ class RequestScopeStorage {
         return this.asyncLocalStorage.getStore();
     }
 }
-exports.RequestScopeStorage = RequestScopeStorage;
-exports.requestScopeStorage = RequestScopeStorage.getInstance();
+export const requestScopeStorage = RequestScopeStorage.getInstance();

package/dist/core/decorators/apply-decorators.js

@@ -1,9 +1,5 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.applyDecorators = applyDecorators;
-exports.SetMetadata = SetMetadata;
-require("reflect-metadata");
-function applyDecorators(...decorators) {
+import 'reflect-metadata';
+export function applyDecorators(...decorators) {
     return ((target, propertyKey, descriptor) => {
         for (const decorator of decorators.reverse()) {
             if (descriptor) {
@@ -27,7 +23,7 @@ function applyDecorators(...decorators) {
         }
     });
 }
-function SetMetadata(key, value) {
+export function SetMetadata(key, value) {
     const decoratorFactory = (target, propertyKey, descriptor) => {
         if (descriptor) {
             Reflect.defineMetadata(key, value, target.constructor, propertyKey);

package/dist/core/decorators/autowired.decorator.d.ts

@@ -1,5 +1,5 @@
 import 'reflect-metadata';
-import { Token } from '../container/injection-token';
+import { Token } from '../container/injection-token.js';
 export interface AutowiredMetadata {
     token: Token;
     index?: number;

package/dist/core/decorators/autowired.decorator.js

@@ -1,10 +1,6 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Autowired = Autowired;
-exports.Optional = Optional;
-require("reflect-metadata");
-const constants_1 = require("../constants");
-function Autowired(token, name) {
+import 'reflect-metadata';
+import { INJECT_METADATA, AUTOWIRED_METADATA } from '../constants.js';
+export function Autowired(token, name) {
     return (target, propertyKey, parameterIndex) => {
         if (typeof parameterIndex === 'number') {
             const paramTypes = Reflect.getMetadata('design:paramtypes', target) ?? [];
@@ -14,13 +10,13 @@ function Autowired(token, name) {
                 throw new Error(`@Autowired() on constructor parameter ${parameterIndex} of ${target.name} ` +
                     `could not infer type. Please provide a token explicitly.`);
             }
-            const existingInjects = Reflect.getMetadata(constants_1.INJECT_METADATA, target) ?? [];
+            const existingInjects = Reflect.getMetadata(INJECT_METADATA, target) ?? [];
             existingInjects.push({
                 token: resolvedToken,
                 index: parameterIndex,
                 name,
             });
-            Reflect.defineMetadata(constants_1.INJECT_METADATA, existingInjects, target);
+            Reflect.defineMetadata(INJECT_METADATA, existingInjects, target);
         }
         else if (propertyKey !== undefined) {
             const inferredType = Reflect.getMetadata('design:type', target, propertyKey);
@@ -29,20 +25,20 @@ function Autowired(token, name) {
                 throw new Error(`@Autowired() on ${target.constructor.name}.${String(propertyKey)} ` +
                     `could not infer type. Please provide a token explicitly.`);
             }
-            const existingAutowires = Reflect.getMetadata(constants_1.AUTOWIRED_METADATA, target.constructor) ?? [];
+            const existingAutowires = Reflect.getMetadata(AUTOWIRED_METADATA, target.constructor) ?? [];
             existingAutowires.push({
                 token: resolvedToken,
                 propertyKey: String(propertyKey),
                 name,
             });
-            Reflect.defineMetadata(constants_1.AUTOWIRED_METADATA, existingAutowires, target.constructor);
+            Reflect.defineMetadata(AUTOWIRED_METADATA, existingAutowires, target.constructor);
         }
     };
 }
-function Optional() {
+export function Optional() {
     return (target, propertyKey, parameterIndex) => {
         if (typeof parameterIndex === 'number') {
-            const existingInjects = Reflect.getMetadata(constants_1.INJECT_METADATA, target) ?? [];
+            const existingInjects = Reflect.getMetadata(INJECT_METADATA, target) ?? [];
             let meta = existingInjects.find(m => m.index === parameterIndex);
             if (meta) {
                 meta.optional = true;
@@ -58,10 +54,10 @@ function Optional() {
                     });
                 }
             }
-            Reflect.defineMetadata(constants_1.INJECT_METADATA, existingInjects, target);
+            Reflect.defineMetadata(INJECT_METADATA, existingInjects, target);
         }
         else if (propertyKey !== undefined) {
-            const existingAutowires = Reflect.getMetadata(constants_1.AUTOWIRED_METADATA, target.constructor) ?? [];
+            const existingAutowires = Reflect.getMetadata(AUTOWIRED_METADATA, target.constructor) ?? [];
             let meta = existingAutowires.find(m => m.propertyKey === String(propertyKey));
             if (meta) {
                 meta.optional = true;
@@ -76,7 +72,7 @@ function Optional() {
                     });
                 }
             }
-            Reflect.defineMetadata(constants_1.AUTOWIRED_METADATA, existingAutowires, target.constructor);
+            Reflect.defineMetadata(AUTOWIRED_METADATA, existingAutowires, target.constructor);
         }
     };
 }

package/dist/core/decorators/config-property.decorator.js

@@ -1,11 +1,5 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ConfigProperty = ConfigProperty;
-exports.getConfigPropertyMappings = getConfigPropertyMappings;
-exports.hasConfigProperties = hasConfigProperties;
-exports.clearPropertyNameCache = clearPropertyNameCache;
-require("reflect-metadata");
-const constants_1 = require("../constants");
+import 'reflect-metadata';
+import { CONFIG_PROPERTY_METADATA } from '../constants.js';
 const propertyNameCache = new Map();
 function toUpperSnakeCase(propertyName) {
     if (propertyNameCache.has(propertyName)) {
@@ -18,7 +12,7 @@ function toUpperSnakeCase(propertyName) {
     propertyNameCache.set(propertyName, envKey);
     return envKey;
 }
-function ConfigProperty(envKey) {
+export function ConfigProperty(envKey) {
     return (target, propertyKey) => {
         if (typeof propertyKey === 'symbol') {
             throw new Error(`@ConfigProperty: Symbol properties are not supported. ` +
@@ -34,7 +28,7 @@ function ConfigProperty(envKey) {
                 `Use "${finalEnvKey.toUpperCase()}" instead.`);
         }
         const constructor = target.constructor;
-        const existingMappings = Reflect.getMetadata(constants_1.CONFIG_PROPERTY_METADATA, constructor) || [];
+        const existingMappings = Reflect.getMetadata(CONFIG_PROPERTY_METADATA, constructor) || [];
         const duplicate = existingMappings.find(m => m.propertyKey === propertyKey);
         if (duplicate) {
             throw new Error(`@ConfigProperty: Property "${propertyKey}" on class "${constructor.name}" ` +
@@ -50,16 +44,16 @@ function ConfigProperty(envKey) {
             envKey: finalEnvKey,
         };
         const updatedMappings = [...existingMappings, newMapping];
-        Reflect.defineMetadata(constants_1.CONFIG_PROPERTY_METADATA, updatedMappings, constructor);
+        Reflect.defineMetadata(CONFIG_PROPERTY_METADATA, updatedMappings, constructor);
     };
 }
-function getConfigPropertyMappings(target) {
-    return Reflect.getMetadata(constants_1.CONFIG_PROPERTY_METADATA, target) || [];
+export function getConfigPropertyMappings(target) {
+    return Reflect.getMetadata(CONFIG_PROPERTY_METADATA, target) || [];
 }
-function hasConfigProperties(target) {
+export function hasConfigProperties(target) {
     const mappings = getConfigPropertyMappings(target);
     return mappings.length > 0;
 }
-function clearPropertyNameCache() {
+export function clearPropertyNameCache() {
     propertyNameCache.clear();
 }

package/dist/core/decorators/controller.decorator.js

@@ -1,11 +1,8 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Controller = Controller;
-require("reflect-metadata");
-const constants_1 = require("../constants");
-const container_1 = require("../container/container");
-const registry_1 = require("../registry");
-function Controller(prefixOrOptions) {
+import 'reflect-metadata';
+import { CONTROLLER_METADATA, INJECTABLE_METADATA } from '../constants.js';
+import { container } from '../container/container.js';
+import { registry } from '../registry.js';
+export function Controller(prefixOrOptions) {
     return (target) => {
         const prefix = typeof prefixOrOptions === 'string'
             ? prefixOrOptions
@@ -13,9 +10,9 @@ function Controller(prefixOrOptions) {
         const normalizedPrefix = prefix
             ? (prefix.startsWith('/') ? prefix : `/${prefix}`)
             : '';
-        Reflect.defineMetadata(constants_1.CONTROLLER_METADATA, { prefix: normalizedPrefix }, target);
-        Reflect.defineMetadata(constants_1.INJECTABLE_METADATA, { scope: 'singleton' }, target);
-        container_1.container.register(target, { scope: 'singleton' });
-        registry_1.registry.registerController(target);
+        Reflect.defineMetadata(CONTROLLER_METADATA, { prefix: normalizedPrefix }, target);
+        Reflect.defineMetadata(INJECTABLE_METADATA, { scope: 'singleton' }, target);
+        container.register(target, { scope: 'singleton' });
+        registry.registerController(target);
     };
 }

package/dist/core/decorators/create-param-decorator.d.ts

@@ -1,5 +1,5 @@
 import 'reflect-metadata';
-import { ExecutionContext } from '../guards/execution-context';
+import { ExecutionContext } from '../guards/execution-context.js';
 export declare const CUSTOM_PARAM_METADATA: unique symbol;
 export interface CustomParamMetadata<T = unknown> {
     index: number;

package/dist/core/decorators/create-param-decorator.js

@@ -1,26 +1,21 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.CUSTOM_PARAM_METADATA = void 0;
-exports.createParamDecorator = createParamDecorator;
-exports.getCustomParamMetadata = getCustomParamMetadata;
-require("reflect-metadata");
-exports.CUSTOM_PARAM_METADATA = Symbol.for('rikta:custom:param:metadata');
-function createParamDecorator(factory) {
+import 'reflect-metadata';
+export const CUSTOM_PARAM_METADATA = Symbol.for('rikta:custom:param:metadata');
+export function createParamDecorator(factory) {
     return (data) => {
         return (target, propertyKey, parameterIndex) => {
             if (propertyKey === undefined)
                 return;
-            const existingParams = Reflect.getMetadata(exports.CUSTOM_PARAM_METADATA, target.constructor, propertyKey) ?? [];
+            const existingParams = Reflect.getMetadata(CUSTOM_PARAM_METADATA, target.constructor, propertyKey) ?? [];
             const metadata = {
                 index: parameterIndex,
                 factory: factory,
                 data,
             };
             existingParams.push(metadata);
-            Reflect.defineMetadata(exports.CUSTOM_PARAM_METADATA, existingParams, target.constructor, propertyKey);
+            Reflect.defineMetadata(CUSTOM_PARAM_METADATA, existingParams, target.constructor, propertyKey);
         };
     };
 }
-function getCustomParamMetadata(target, propertyKey) {
-    return Reflect.getMetadata(exports.CUSTOM_PARAM_METADATA, target, propertyKey) ?? [];
+export function getCustomParamMetadata(target, propertyKey) {
+    return Reflect.getMetadata(CUSTOM_PARAM_METADATA, target, propertyKey) ?? [];
 }

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

@@ -1,9 +1,9 @@
-export * from './injectable.decorator';
-export * from './controller.decorator';
-export * from './route.decorator';
-export * from './param.decorator';
-export * from './autowired.decorator';
-export * from './provider.decorator';
-export * from './config-property.decorator';
-export * from './create-param-decorator';
-export * from './apply-decorators';
+export * from './injectable.decorator.js';
+export * from './controller.decorator.js';
+export * from './route.decorator.js';
+export * from './param.decorator.js';
+export * from './autowired.decorator.js';
+export * from './provider.decorator.js';
+export * from './config-property.decorator.js';
+export * from './create-param-decorator.js';
+export * from './apply-decorators.js';

package/dist/core/decorators/index.js

@@ -1,25 +1,9 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-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 });
-__exportStar(require("./injectable.decorator"), exports);
-__exportStar(require("./controller.decorator"), exports);
-__exportStar(require("./route.decorator"), exports);
-__exportStar(require("./param.decorator"), exports);
-__exportStar(require("./autowired.decorator"), exports);
-__exportStar(require("./provider.decorator"), exports);
-__exportStar(require("./config-property.decorator"), exports);
-__exportStar(require("./create-param-decorator"), exports);
-__exportStar(require("./apply-decorators"), exports);
+export * from './injectable.decorator.js';
+export * from './controller.decorator.js';
+export * from './route.decorator.js';
+export * from './param.decorator.js';
+export * from './autowired.decorator.js';
+export * from './provider.decorator.js';
+export * from './config-property.decorator.js';
+export * from './create-param-decorator.js';
+export * from './apply-decorators.js';

package/dist/core/decorators/injectable.decorator.d.ts

@@ -1,3 +1,3 @@
 import 'reflect-metadata';
-import { InjectableOptions } from '../types';
+import { InjectableOptions } from '../types.js';
 export declare function Injectable(options?: InjectableOptions): ClassDecorator;

package/dist/core/decorators/injectable.decorator.js

@@ -1,14 +1,11 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Injectable = Injectable;
-require("reflect-metadata");
-const constants_1 = require("../constants");
-const container_1 = require("../container/container");
-const registry_1 = require("../registry");
-function Injectable(options = {}) {
+import 'reflect-metadata';
+import { INJECTABLE_METADATA } from '../constants.js';
+import { container } from '../container/container.js';
+import { registry } from '../registry.js';
+export function Injectable(options = {}) {
     return (target) => {
-        Reflect.defineMetadata(constants_1.INJECTABLE_METADATA, options, target);
-        container_1.container.register(target, options);
-        registry_1.registry.registerProvider(target);
+        Reflect.defineMetadata(INJECTABLE_METADATA, options, target);
+        container.register(target, options);
+        registry.registerProvider(target);
     };
 }