@tstdl/base 0.84.14 → 0.84.16

package/application/application.d.ts

@@ -7,8 +7,7 @@ export declare class Application {
     private static _instance;
     private static get instance();
     private readonly logger;
-    private readonly moduleTypes;
-    private readonly moduleInstances;
+    private readonly moduleTypesAndInstances;
     private readonly shutdownPromise;
     private readonly _shutdownToken;
     get shutdownToken(): ReadonlyCancellationToken;
@@ -16,14 +15,12 @@ export declare class Application {
     constructor(logger: Logger);
     static registerModule(moduleType: Type<Module>): void;
     static registerModuleFunction(fn: FunctionModuleFunction): void;
-    static registerModuleInstance(module: Module): void;
     static run(...functionsAndModules: OneOrMany<FunctionModuleFunction | Type<Module>>[]): void;
     static waitForShutdown(): Promise<void>;
     static shutdown(): Promise<void>;
     static requestShutdown(): void;
-    registerModule(moduleType: Type<Module>): void;
+    registerModule(moduleType: Module | Type<Module>): void;
     registerModuleFunction(fn: FunctionModuleFunction): void;
-    registerModuleInstance(module: Module): void;
     run(...functionsAndModules: OneOrMany<FunctionModuleFunction | Type<Module>>[]): void;
     shutdown(): Promise<void>;
     requestShutdown(): void;

package/application/application.js

@@ -63,8 +63,7 @@ let Application = Application_1 = class Application2 {
     return this._instance;
   }
   logger;
-  moduleTypes;
-  moduleInstances;
+  moduleTypesAndInstances;
   shutdownPromise;
   _shutdownToken;
   get shutdownToken() {
@@ -75,8 +74,7 @@ let Application = Application_1 = class Application2 {
   }
   constructor(logger) {
     this.logger = logger;
-    this.moduleTypes = /* @__PURE__ */ new Set();
-    this.moduleInstances = /* @__PURE__ */ new Set();
+    this.moduleTypesAndInstances = /* @__PURE__ */ new Set();
     this.shutdownPromise = new import_deferred_promise.DeferredPromise();
     this._shutdownToken = import_process_shutdown.shutdownToken.createChild();
   }
@@ -86,9 +84,6 @@ let Application = Application_1 = class Application2 {
   static registerModuleFunction(fn) {
     Application_1.instance.registerModuleFunction(fn);
   }
-  static registerModuleInstance(module2) {
-    Application_1.instance.registerModuleInstance(module2);
-  }
   static run(...functionsAndModules) {
     Application_1.instance.run(...functionsAndModules);
   }
@@ -102,14 +97,11 @@ let Application = Application_1 = class Application2 {
     Application_1.instance.requestShutdown();
   }
   registerModule(moduleType) {
-    this.moduleTypes.add(moduleType);
+    this.moduleTypesAndInstances.add(moduleType);
   }
   registerModuleFunction(fn) {
     const module2 = new import_function_module.FunctionModule(fn);
-    this.registerModuleInstance(module2);
-  }
-  registerModuleInstance(module2) {
-    this.moduleInstances.add(module2);
+    this.registerModule(module2);
   }
   run(...functionsAndModules) {
     void this._run(...functionsAndModules);
@@ -135,8 +127,7 @@ let Application = Application_1 = class Application2 {
         this.registerModuleFunction(fnOrModule);
       }
     }
-    const resolvedModules = await (0, import_to_array.toArrayAsync)((0, import_map.mapAsync)(this.moduleTypes, async (type) => import_container.container.resolveAsync(type)));
-    const modules = [...this.moduleInstances, ...resolvedModules];
+    const modules = await (0, import_to_array.toArrayAsync)((0, import_map.mapAsync)(this.moduleTypesAndInstances, async (instanceOrType) => (0, import_type_guards.isFunction)(instanceOrType) ? import_container.container.resolveAsync(instanceOrType) : instanceOrType));
     try {
       await Promise.race([
         this.runModules(modules),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tstdl/base",
-  "version": "0.84.14",
+  "version": "0.84.16",
   "author": "Patrick Hein",
   "publishConfig": {
     "access": "public"

package/process-shutdown.js

@@ -63,7 +63,7 @@ function initializeSignals() {
   let quitReason;
   process.on("beforeExit", () => {
     if ((0, import_type_guards.isDefined)(quitReason)) {
-      console.info("quit reason:", ...quitReason);
+      console.info("\nquit reason:", ...quitReason);
     }
   });
   for (const event of quitEvents) {

package/schema/coercers/uint8-array.coercer.d.ts

@@ -1,7 +1,9 @@
 import type { JsonPath } from '../../json-path/json-path.js';
-import type { CoercerContext, CoerceResult } from '../types/index.js';
+import type { Schema } from '../schema.js';
+import type { CoerceResult, CoercerContext } from '../types/index.js';
 import { SchemaValueCoercer } from '../types/index.js';
 export declare class Uint8ArrayCoercer extends SchemaValueCoercer {
+    static readonly byteNumberArraySchema: Schema<number[]>;
     readonly sourceType: ArrayConstructor;
     readonly targetType: Uint8ArrayConstructor;
     coerce(value: any[], path: JsonPath, { options }: CoercerContext): CoerceResult;

package/schema/coercers/uint8-array.coercer.js

@@ -22,17 +22,21 @@ __export(uint8_array_coercer_exports, {
   uint8ArrayCoercer: () => uint8ArrayCoercer
 });
 module.exports = __toCommonJS(uint8_array_coercer_exports);
-var import_schema = require("../schema.js");
+var import_lazy_property = require("../../utils/object/lazy-property.js");
 var import_schema_error = require("../schema.error.js");
+var import_schema = require("../schema.js");
 var import_array = require("../schemas/array.js");
 var import_number = require("../schemas/number.js");
 var import_types = require("../types/index.js");
-const byteNumberArraySchema = (0, import_array.array)((0, import_number.number)({ integer: true, minimum: 0, maximum: 255 }));
 class Uint8ArrayCoercer extends import_types.SchemaValueCoercer {
+  static byteNumberArraySchema;
+  static {
+    (0, import_lazy_property.lazyProperty)(this, "byteNumberArraySchema", () => (0, import_array.array)((0, import_number.number)({ integer: true, minimum: 0, maximum: 255 })));
+  }
   sourceType = Array;
   targetType = Uint8Array;
   coerce(value, path, { options }) {
-    const testResult = (0, import_schema.testSchema)(byteNumberArraySchema, value, options, path);
+    const testResult = (0, import_schema.testSchema)(Uint8ArrayCoercer.byteNumberArraySchema, value, options, path);
     if (!testResult.valid) {
       return { success: false, error: import_schema_error.SchemaError.couldNotCoerce(Uint8Array, Array, path, { inner: testResult.error, fast: options.fastErrors }) };
     }

package/schema/schemas/number.js

@@ -27,7 +27,7 @@ var import_type_guards = require("../../utils/type-guards.js");
 var import_integer = require("../constraints/integer.js");
 var import_maximum = require("../constraints/maximum.js");
 var import_minimum = require("../constraints/minimum.js");
-var import_decorators = require("../decorators/index.js");
+var import_utils = require("../decorators/utils.js");
 var import_types = require("../types/types.js");
 function number(options = {}) {
   const valueConstraints = (0, import_array.toArrayCopy)(options.valueConstraints ?? []);
@@ -46,5 +46,5 @@ function number(options = {}) {
   });
 }
 function NumberProperty(options) {
-  return (0, import_decorators.createSchemaPropertyDecoratorFromSchema)(number(options));
+  return (0, import_utils.createSchemaPropertyDecoratorFromSchema)(number(options));
 }