@velajs/vela 1.18.0 → 1.19.1

package/dist/registry/metadata.registry.js

@@ -1,357 +0,0 @@
-import { getOrCreate, getOrCreateArray, getOrCreateMap } from "./util.js";
-function emptyComponentByOwner() {
-    return {
-        middleware: new Map(),
-        guard: new Map(),
-        pipe: new Map(),
-        interceptor: new Map(),
-        filter: new Map()
-    };
-}
-function createRegistryState() {
-    return {
-        routes: new Map(),
-        controllers: new Map(),
-        controllerOptions: new Map(),
-        modules: new Map(),
-        parameters: new Map(),
-        injectables: new Set(),
-        scopes: new Map(),
-        injectTokens: new Map(),
-        handlerHttpMeta: new Map(),
-        catchTypes: new Map(),
-        routeVersions: new Map(),
-        classMeta: new Map(),
-        handlerMeta: new Map(),
-        classMetaIndex: new Map(),
-        handlerMetaIndex: new Map(),
-        controllerComponents: emptyComponentByOwner(),
-        handlerComponents: {
-            middleware: new Map(),
-            guard: new Map(),
-            pipe: new Map(),
-            interceptor: new Map(),
-            filter: new Map()
-        }
-    };
-}
-// HMR-safe: anchor ALL backing state on `globalThis` so a Vite dev re-eval of
-// this module reuses the SAME maps that classes were already decorated against.
-// Without this, re-eval creates fresh empty statics → split-brain (lost routes,
-// spurious "not @Injectable" warnings, duplicated global components). The
-// versioned symbol avoids collisions across framework major versions in one
-// process. `globalThis` + `Symbol.for` exist on every target runtime; no node:*.
-const REGISTRY_STATE_KEY = Symbol.for('vela:registry:v1');
-// Shared empty result for index misses — avoids allocating per lookup.
-const EMPTY_TARGET_SET = new Set();
-function registryState() {
-    const g = globalThis;
-    const state = g[REGISTRY_STATE_KEY] ??= createRegistryState();
-    // Backfill fields added after the v1 state shape was first anchored: a state
-    // created by an older copy of this module (dist/src coexistence in tests,
-    // mixed package versions in one process) must not crash newer readers.
-    state.classMetaIndex ??= new Map();
-    state.handlerMetaIndex ??= new Map();
-    return state;
-}
-export class MetadataRegistry {
-    // Every field is a getter over the globalThis-anchored state (registryState).
-    // Method bodies keep using `this.<field>`; the getter returns the live map so
-    // `.set`/`.get`/`.clear` mutate the shared state.
-    static get routes() {
-        return registryState().routes;
-    }
-    static get controllers() {
-        return registryState().controllers;
-    }
-    static get controllerOptions() {
-        return registryState().controllerOptions;
-    }
-    static get modules() {
-        return registryState().modules;
-    }
-    static get parameters() {
-        return registryState().parameters;
-    }
-    static get injectables() {
-        return registryState().injectables;
-    }
-    static get scopes() {
-        return registryState().scopes;
-    }
-    static get injectTokens() {
-        return registryState().injectTokens;
-    }
-    static get handlerHttpMeta() {
-        return registryState().handlerHttpMeta;
-    }
-    static get catchTypes() {
-        return registryState().catchTypes;
-    }
-    static get routeVersions() {
-        return registryState().routeVersions;
-    }
-    static get classMeta() {
-        return registryState().classMeta;
-    }
-    static get handlerMeta() {
-        return registryState().handlerMeta;
-    }
-    static get classMetaIndex() {
-        return registryState().classMetaIndex;
-    }
-    static get handlerMetaIndex() {
-        return registryState().handlerMetaIndex;
-    }
-    static get controllerComponents() {
-        return registryState().controllerComponents;
-    }
-    static get handlerComponents() {
-        return registryState().handlerComponents;
-    }
-    // Routes
-    static getRoutes(controller) {
-        return this.routes.get(controller) ?? [];
-    }
-    static addRoute(controller, route) {
-        getOrCreateArray(this.routes, controller).push(route);
-    }
-    // Controllers
-    static getControllerPath(controller) {
-        return this.controllers.get(controller) ?? '';
-    }
-    static setControllerPath(controller, path) {
-        this.controllers.set(controller, path);
-    }
-    static getControllerOptions(controller) {
-        return this.controllerOptions.get(controller) ?? {};
-    }
-    static setControllerOptions(controller, options) {
-        this.controllerOptions.set(controller, options);
-    }
-    // Modules
-    static getModuleOptions(module) {
-        return this.modules.get(module);
-    }
-    static setModuleOptions(module, options) {
-        this.modules.set(module, options);
-    }
-    // Parameters
-    static getParameters(controller) {
-        return this.parameters.get(controller) ?? new Map();
-    }
-    static addParameter(controller, methodName, param) {
-        const methodMap = getOrCreateMap(this.parameters, controller);
-        getOrCreateArray(methodMap, methodName).push(param);
-    }
-    // Component registration — controller-level. (There is deliberately NO
-    // global tier here: app-wide components live on the per-app RouteManager,
-    // one source, never process-global state.)
-    static registerController(type, controller, component) {
-        const map = this.controllerComponents[type];
-        getOrCreateArray(map, controller).push(component);
-    }
-    static getController(type, controller) {
-        const map = this.controllerComponents[type];
-        return map.get(controller) ?? [];
-    }
-    // Component registration — handler-level
-    static registerHandler(type, controller, methodName, component) {
-        const map = this.handlerComponents[type];
-        const methodMap = getOrCreateMap(map, controller);
-        getOrCreateArray(methodMap, methodName).push(component);
-    }
-    static getHandler(type, controller, methodName) {
-        const map = this.handlerComponents[type];
-        return map.get(controller)?.get(methodName) ?? [];
-    }
-    // DI metadata
-    static markInjectable(target) {
-        this.injectables.add(target);
-    }
-    static hasInjectable(target) {
-        return this.injectables.has(target);
-    }
-    static setScope(target, scope) {
-        this.scopes.set(target, scope);
-    }
-    static getScope(target) {
-        return this.scopes.get(target);
-    }
-    static setInjectTokens(target, tokens) {
-        this.injectTokens.set(target, tokens);
-    }
-    static getInjectTokens(target) {
-        return this.injectTokens.get(target);
-    }
-    // HTTP handler metadata
-    static setHandlerHttpMeta(controller, method, meta) {
-        const methodMap = getOrCreateMap(this.handlerHttpMeta, controller);
-        const existing = methodMap.get(method) ?? {};
-        const merged = {
-            ...existing,
-            ...meta
-        };
-        if (meta.responseHeaders) {
-            merged.responseHeaders = [
-                ...existing.responseHeaders ?? [],
-                ...meta.responseHeaders
-            ];
-        }
-        methodMap.set(method, merged);
-    }
-    static getHandlerHttpMeta(controller, method) {
-        return this.handlerHttpMeta.get(controller)?.get(method);
-    }
-    // Exception filter types
-    static setCatchTypes(filter, types) {
-        this.catchTypes.set(filter, types);
-    }
-    static getCatchTypes(filter) {
-        return this.catchTypes.get(filter);
-    }
-    static hasCatchTypes(filter) {
-        return this.catchTypes.has(filter);
-    }
-    // Route versions
-    static setRouteVersion(controller, method, version) {
-        getOrCreateMap(this.routeVersions, controller).set(method, version);
-    }
-    static getRouteVersion(controller, method) {
-        return this.routeVersions.get(controller)?.get(method);
-    }
-    // Custom class/handler metadata. One slot per (target, key) for class-level,
-    // (target, handler, key) for handler-level. The same slots back @SetMetadata,
-    // every feature decorator (@Cron, @OnEvent, @ApiDoc, …), the SWC shim, and
-    // external Reflect.defineMetadata calls — one model, one source of truth.
-    static setCustomClassMeta(target, key, value) {
-        getOrCreate(this.classMeta, target, ()=>new Map()).set(key, value);
-        if (!key.startsWith('design:')) {
-            getOrCreate(this.classMetaIndex, key, ()=>new Set()).add(target);
-        }
-    }
-    static getCustomClassMeta(target, key) {
-        return this.classMeta.get(target)?.get(key);
-    }
-    static getCustomClassMetaAll(target) {
-        return this.classMeta.get(target);
-    }
-    static setCustomHandlerMeta(target, handler, key, value) {
-        const byHandler = getOrCreate(this.handlerMeta, target, ()=>new Map());
-        getOrCreate(byHandler, handler, ()=>new Map()).set(key, value);
-        if (!key.startsWith('design:')) {
-            getOrCreate(this.handlerMetaIndex, key, ()=>new Set()).add(target);
-        }
-    }
-    static getCustomHandlerMeta(target, handler, key) {
-        return this.handlerMeta.get(target)?.get(handler)?.get(key);
-    }
-    static getCustomHandlerMetaAll(target, handler) {
-        return this.handlerMeta.get(target)?.get(handler);
-    }
-    // Append helpers — for stackable metadata like @Cron / @Interval / @OnEvent / @ApiResponse.
-    static appendCustomClassMeta(target, key, item) {
-        const list = this.getCustomClassMeta(target, key) ?? [];
-        list.push(item);
-        this.setCustomClassMeta(target, key, list);
-    }
-    static appendCustomHandlerMeta(target, handler, key, item) {
-        const list = this.getCustomHandlerMeta(target, handler, key) ?? [];
-        list.push(item);
-        this.setCustomHandlerMeta(target, handler, key, list);
-    }
-    // Reverse-index readers — the DiscoveryService seam. Return the constructors
-    // known to carry class-level (resp. handler-level) metadata under `key`.
-    // Callers must still intersect with container-registered tokens: decoration
-    // alone does not make a class a provider.
-    static getClassesWithClassMeta(key) {
-        return this.classMetaIndex.get(key) ?? EMPTY_TARGET_SET;
-    }
-    static getClassesWithHandlerMeta(key) {
-        return this.handlerMetaIndex.get(key) ?? EMPTY_TARGET_SET;
-    }
-    /** Every (handler, value) pair on `target` carrying metadata under `key`. */ static getHandlersWithMeta(target, key) {
-        const byHandler = this.handlerMeta.get(target);
-        if (!byHandler) return [];
-        const out = [];
-        for (const [handler, metaMap] of byHandler){
-            if (metaMap.has(key)) out.push({
-                handler,
-                value: metaMap.get(key)
-            });
-        }
-        return out;
-    }
-    // Reflect-style API — same storage as the typed setters above. Lets external
-    // code (and the SWC shim's Reflect.metadata polyfill) write/read uniformly.
-    static setReflectMetadata(target, key, value, propertyKey) {
-        if (propertyKey !== undefined) {
-            this.setCustomHandlerMeta(target, propertyKey, key, value);
-        } else {
-            this.setCustomClassMeta(target, key, value);
-        }
-    }
-    static getReflectMetadata(target, key, propertyKey) {
-        if (propertyKey !== undefined) {
-            return this.getCustomHandlerMeta(target, propertyKey, key);
-        }
-        return this.getCustomClassMeta(target, key);
-    }
-    // SWC-emitted design:paramtypes — class-level for constructors, handler-level for methods.
-    static getParamTypes(target, propertyKey) {
-        return this.getReflectMetadata(target, 'design:paramtypes', propertyKey);
-    }
-    // Propagate all controller-level components from one class to another.
-    static propagateControllerComponents(from, to) {
-        for (const type of [
-            'middleware',
-            'guard',
-            'pipe',
-            'interceptor',
-            'filter'
-        ]){
-            const map = this.controllerComponents[type];
-            const components = map.get(from);
-            if (components && components.length > 0) {
-                const target = getOrCreateArray(map, to);
-                target.push(...components);
-            }
-        }
-    }
-    // Clear app-time state. Decoration metadata persists — once a class is
-    // decorated, that fact is permanent for the lifetime of the process.
-    // Currently a no-op: the last piece of app-time registry state (the global
-    // component tier) moved to the per-app RouteManager. Kept because test
-    // suites call it between cases and future app-time state belongs here.
-    static clear() {
-    // no app-time state to clear
-    }
-    // Full reset, including decoration metadata. Used in framework-internal scenarios.
-    static reset() {
-        this.routes.clear();
-        this.controllers.clear();
-        this.controllerOptions.clear();
-        this.modules.clear();
-        this.parameters.clear();
-        this.injectables.clear();
-        this.scopes.clear();
-        this.injectTokens.clear();
-        this.handlerHttpMeta.clear();
-        this.catchTypes.clear();
-        this.routeVersions.clear();
-        this.classMeta.clear();
-        this.handlerMeta.clear();
-        this.classMetaIndex.clear();
-        this.handlerMetaIndex.clear();
-        for (const type of [
-            'middleware',
-            'guard',
-            'pipe',
-            'interceptor',
-            'filter'
-        ]){
-            this.controllerComponents[type].clear();
-            this.handlerComponents[type].clear();
-        }
-    }
-}

package/dist/registry/paths.d.ts

@@ -1,3 +0,0 @@
-export declare function normalizePath(path: string): string;
-export declare function joinPaths(prefix: string, path: string): string;
-export declare function toOpenApiPath(path: string): string;

package/dist/registry/paths.js

@@ -1,15 +0,0 @@
-// Single home for path manipulation. Used by route building, openapi docs,
-// and decorator metadata.
-export function normalizePath(path) {
-    if (!path) return path;
-    return path.startsWith('/') ? path : `/${path}`;
-}
-export function joinPaths(prefix, path) {
-    const cleanPrefix = prefix.endsWith('/') ? prefix.slice(0, -1) : prefix;
-    const cleanPath = path && !path.startsWith('/') ? `/${path}` : path;
-    return `${cleanPrefix}${cleanPath}` || '/';
-}
-// Convert ':id' Hono syntax to '{id}' OpenAPI syntax.
-export function toOpenApiPath(path) {
-    return path.replace(/:([a-zA-Z_][a-zA-Z0-9_]*)/g, '{$1}');
-}

package/dist/registry/types.d.ts

@@ -1,116 +0,0 @@
-import type { Context } from 'hono';
-import type { CanActivate, ExceptionFilter, NestInterceptor, NestMiddleware, PipeTransform } from '../pipeline/types';
-import type { Constructor, ForwardRef, InferToken, InferTokens, InjectionToken, ProviderOptions, Token, Type } from '../container/types';
-export type { Constructor, ForwardRef, InferToken, InferTokens, InjectionToken, ProviderOptions, Token, Type };
-export type ComponentType = 'middleware' | 'guard' | 'pipe' | 'interceptor' | 'filter';
-export type MiddlewareType = Type<NestMiddleware> | NestMiddleware;
-export type GuardType = Type<CanActivate> | CanActivate;
-export type PipeType = Type<PipeTransform> | PipeTransform;
-export type InterceptorType = Type<NestInterceptor> | NestInterceptor;
-export type FilterType = Type<ExceptionFilter> | ExceptionFilter;
-export interface ComponentTypeMap {
-    middleware: MiddlewareType;
-    guard: GuardType;
-    pipe: PipeType;
-    interceptor: InterceptorType;
-    filter: FilterType;
-}
-export type ComponentInstance = MiddlewareType | GuardType | PipeType | InterceptorType | FilterType;
-export interface RouteDefinition {
-    method: string;
-    path: string;
-    handlerName: string | symbol;
-    version?: number | number[];
-    /** Route name for URL generation / OpenAPI operationId (`@Get(path, { name })`). */
-    name?: string;
-}
-export interface ParameterMetadata {
-    index: number;
-    type: string;
-    name?: string;
-    pipes?: PipeType[];
-    factory?: (data: unknown, ctx: Context) => unknown;
-    /**
-     * Explicit param type for programmatic routes. Methods synthesized at
-     * runtime (e.g. `@Crud()` verb handlers) have no `design:paramtypes`, so
-     * ValidationPipe and the OpenAPI walk read this instead when present.
-     */
-    metatype?: unknown;
-}
-export interface HttpHandlerMeta {
-    httpCode?: number;
-    responseHeaders?: Array<[string, string]>;
-    redirect?: {
-        url: string;
-        statusCode: number;
-    };
-}
-export type ModuleImport = Type | DynamicModule | ForwardRef;
-/**
- * Async module options with **type-inferred `useFactory` parameters**.
- *
- * The `Inject` generic captures the literal `inject` tuple via `const` type
- * parameter inference at the call site (TS 5.0+ — vela already requires it).
- * `useFactory`'s parameter types are computed from that tuple via
- * `InferTokens<Inject>`, so:
- *
- * ```ts
- * SomeModule.forRootAsync({
- *   inject: [D1Service, ConfigService],   // captured as readonly [typeof D1Service, typeof ConfigService]
- *   useFactory: (d1, config) => { ... },  // d1: D1Service, config: ConfigService — inferred
- * });
- * ```
- *
- * Backwards compatible: when `inject` isn't a literal tuple (or is omitted),
- * `Inject` falls back to `readonly Token<unknown>[]`, `InferTokens` resolves
- * to `unknown[]`, and `useFactory` accepts variadic `unknown[]` — the prior
- * loose-typing behavior. Existing callers don't break.
- */
-export interface AsyncModuleOptions<T = unknown, Inject extends readonly Token<unknown>[] = readonly Token<unknown>[]> {
-    imports?: ModuleImport[];
-    inject?: Inject;
-    useFactory: (...args: InferTokens<Inject>) => T | Promise<T>;
-}
-export interface DynamicModule {
-    module: Type;
-    /**
-     * Author-supplied instance discriminator. Two DynamicModules with the same
-     * `module` class and the same `key` dedup; with different keys they coexist
-     * as separate module instances. Defaults to `"default"` when absent — which
-     * preserves single-instance dedup for the common case.
-     *
-     * For `forRoot(options)`, derive `key: stableHash(options)` so identical
-     * options dedup automatically. For `forRootAsync` (factories aren't
-     * structurally hashable), pass an explicit string.
-     */
-    key?: string;
-    imports?: ModuleImport[];
-    providers?: Array<Type | ProviderOptions>;
-    controllers?: Type[];
-    exports?: Array<Type | InjectionToken>;
-    global?: boolean;
-    /**
-     * Defer this module instance's providers/controllers to first use: nothing
-     * constructs at bootstrap; the first resolution of any of its tokens
-     * materializes the whole group and replays its lifecycle hooks (memoized).
-     * See MODULE_AUTHORING.md "Lazy modules" for the contract.
-     */
-    lazy?: boolean;
-}
-export interface ModuleOptions {
-    providers?: Array<Type | ProviderOptions>;
-    controllers?: Type[];
-    imports?: ModuleImport[];
-    exports?: Array<Type | InjectionToken>;
-    isGlobal?: boolean;
-    /** Defer to first use (see {@link DynamicModule.lazy}). */
-    lazy?: boolean;
-}
-export interface ModuleMetadata {
-    providers: Array<Type | ProviderOptions>;
-    controllers: Type[];
-    imports: ModuleImport[];
-    exports: Array<Type | InjectionToken>;
-    isGlobal: boolean;
-    lazy: boolean;
-}

package/dist/registry/types.js

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

package/dist/registry/util.d.ts

@@ -1,3 +0,0 @@
-export declare function getOrCreate<K, V>(map: Map<K, V>, key: K, factory: () => V): V;
-export declare const getOrCreateMap: <K, NK, NV>(map: Map<K, Map<NK, NV>>, key: K) => Map<NK, NV>;
-export declare const getOrCreateArray: <K, V>(map: Map<K, V[]>, key: K) => V[];

package/dist/registry/util.js

@@ -1,8 +0,0 @@
-// Single map.get + optional set. Replaces `map.has(key) || map.set(key, …); map.get(key)!` patterns.
-export function getOrCreate(map, key, factory) {
-    let v = map.get(key);
-    if (v === undefined) map.set(key, v = factory());
-    return v;
-}
-export const getOrCreateMap = (map, key)=>getOrCreate(map, key, ()=>new Map());
-export const getOrCreateArray = (map, key)=>getOrCreate(map, key, ()=>[]);

package/dist/schedule/cron-matcher.d.ts

@@ -1,2 +0,0 @@
-export type CronMatcher = (date: Date) => boolean;
-export declare function parseCron(expression: string): CronMatcher | null;

package/dist/schedule/cron-matcher.js

@@ -1,62 +0,0 @@
-export function parseCron(expression) {
-    const fields = expression.trim().split(/\s+/);
-    if (fields.length !== 5) return null;
-    const [minuteField, hourField, dayField, monthField, weekdayField] = fields;
-    const minute = parseField(minuteField, 0, 59);
-    const hour = parseField(hourField, 0, 23);
-    const day = parseField(dayField, 1, 31);
-    const month = parseField(monthField, 1, 12);
-    const weekday = parseField(weekdayField, 0, 7);
-    if (!minute || !hour || !day || !month || !weekday) return null;
-    return (date)=>minute(date.getMinutes()) && hour(date.getHours()) && day(date.getDate()) && month(date.getMonth() + 1) && weekday(date.getDay());
-}
-function parseField(field, min, max) {
-    const segments = field.split(',');
-    const predicates = [];
-    for (const rawSegment of segments){
-        const segment = rawSegment.trim();
-        if (!segment) return null;
-        const stepParts = segment.split('/');
-        if (stepParts.length > 2) return null;
-        const step = stepParts.length === 2 ? Number(stepParts[1]) : 1;
-        if (!Number.isInteger(step) || step <= 0) return null;
-        const range = parseRange(stepParts[0], min, max);
-        if (!range) return null;
-        predicates.push((value)=>{
-            if (value < range.start || value > range.end) return false;
-            return (value - range.start) % step === 0;
-        });
-    }
-    return (value)=>predicates.some((p)=>p(value));
-}
-function parseRange(segment, min, max) {
-    if (segment === '*') return {
-        start: min,
-        end: max
-    };
-    const bounds = segment.split('-');
-    if (bounds.length === 1) {
-        const value = parseCronNumber(bounds[0], min, max);
-        if (value === null) return null;
-        return {
-            start: value,
-            end: value
-        };
-    }
-    if (bounds.length !== 2) return null;
-    const start = parseCronNumber(bounds[0], min, max);
-    const end = parseCronNumber(bounds[1], min, max);
-    if (start === null || end === null || start > end) return null;
-    return {
-        start,
-        end
-    };
-}
-function parseCronNumber(raw, min, max) {
-    const value = Number(raw);
-    if (!Number.isInteger(value)) return null;
-    // Cron allows 0 and 7 as Sunday.
-    const normalized = max === 7 && value === 7 ? 0 : value;
-    if (normalized < min || normalized > max) return null;
-    return normalized;
-}

package/dist/schedule/index.d.ts

@@ -1,8 +0,0 @@
-export { ScheduleModule } from './schedule.module';
-export { ScheduleRegistry } from './schedule.registry';
-export type { RegisteredCronJob, RegisteredIntervalJob } from './schedule.registry';
-export { Cron, Interval } from './schedule.decorators';
-export { CRON_METADATA, INTERVAL_METADATA } from './schedule.tokens';
-export type { CronMetadata, IntervalMetadata } from './schedule.types';
-export { parseCron } from './cron-matcher';
-export type { CronMatcher } from './cron-matcher';

package/dist/schedule/index.js

@@ -1,5 +0,0 @@
-export { ScheduleModule } from "./schedule.module.js";
-export { ScheduleRegistry } from "./schedule.registry.js";
-export { Cron, Interval } from "./schedule.decorators.js";
-export { CRON_METADATA, INTERVAL_METADATA } from "./schedule.tokens.js";
-export { parseCron } from "./cron-matcher.js";

package/dist/schedule/schedule.decorators.d.ts

@@ -1,2 +0,0 @@
-export declare function Cron(expression: string): MethodDecorator;
-export declare function Interval(ms: number): MethodDecorator;

package/dist/schedule/schedule.decorators.js

@@ -1,18 +0,0 @@
-import { MetadataRegistry } from "../registry/metadata.registry.js";
-import { CRON_METADATA, INTERVAL_METADATA } from "./schedule.tokens.js";
-export function Cron(expression) {
-    return (target, propertyKey)=>{
-        MetadataRegistry.appendCustomClassMeta(target.constructor, CRON_METADATA, {
-            expression,
-            methodName: String(propertyKey)
-        });
-    };
-}
-export function Interval(ms) {
-    return (target, propertyKey)=>{
-        MetadataRegistry.appendCustomClassMeta(target.constructor, INTERVAL_METADATA, {
-            ms,
-            methodName: String(propertyKey)
-        });
-    };
-}

package/dist/schedule/schedule.module.d.ts

@@ -1,9 +0,0 @@
-import type { DynamicModule } from '../module/types';
-/**
- * Zero-config module (Tier C): providers live on the `@Module` bag; the
- * `forRoot()` static is NestJS-parity sugar returning the bare dynamic module
- * (default key — repeated calls dedup).
- */
-export declare class ScheduleModule {
-    static forRoot(): DynamicModule;
-}

package/dist/schedule/schedule.module.js

@@ -1,28 +0,0 @@
-function _ts_decorate(decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    else for(var i = decorators.length - 1; i >= 0; i--)if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
-}
-import { Module } from "../module/decorators.js";
-import { ScheduleRegistry } from "./schedule.registry.js";
-export class ScheduleModule {
-    static forRoot() {
-        return {
-            module: ScheduleModule
-        };
-    }
-}
-ScheduleModule = _ts_decorate([
-    Module({
-        // Lazy: the @Cron/@Interval discovery pass runs when ScheduleRegistry is
-        // first resolved (executor bootstrap, introspection, first dispatch).
-        lazy: true,
-        providers: [
-            ScheduleRegistry
-        ],
-        exports: [
-            ScheduleRegistry
-        ]
-    })
-], ScheduleModule);

package/dist/schedule/schedule.registry.d.ts

@@ -1,23 +0,0 @@
-import { DiscoveryService } from '../discovery/discovery.service';
-import type { OnApplicationBootstrap } from '../lifecycle/index';
-export interface RegisteredCronJob {
-    expression: string;
-    methodName: string;
-    instance: unknown;
-    target: Function;
-}
-export interface RegisteredIntervalJob {
-    ms: number;
-    methodName: string;
-    instance: unknown;
-    target: Function;
-}
-export declare class ScheduleRegistry implements OnApplicationBootstrap {
-    private readonly discovery;
-    private cronJobs;
-    private intervalJobs;
-    constructor(discovery: DiscoveryService);
-    onApplicationBootstrap(): void;
-    getCronJobs(): RegisteredCronJob[];
-    getIntervalJobs(): RegisteredIntervalJob[];
-}