@venok/core 1.1.0 → 2.0.0

package/dist/helpers/validate-each.helper.js

@@ -0,0 +1,42 @@
+import { createRequire } from "node:module";
+var __legacyDecorateClassTS = function(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;
+};
+var __legacyDecorateParamTS = (index, decorator) => (target, key) => decorator(target, key, index);
+var __legacyMetadataTS = (k, v) => {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function")
+    return Reflect.metadata(k, v);
+};
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+// packages/core/src/helpers/validate-each.helper.ts
+class InvalidDecoratorItemException extends Error {
+  msg;
+  constructor(decorator, item, context) {
+    const message = `Invalid ${item} passed to ${decorator}() decorator (${context}).`;
+    super(message);
+    this.msg = message;
+  }
+  what() {
+    return this.msg;
+  }
+}
+function validateEach(context, arr, predicate, decorator, item) {
+  if (!context || !context.name)
+    return true;
+  const errors = arr.some((str) => !predicate(str));
+  if (errors)
+    throw new InvalidDecoratorItemException(decorator, item, context.name);
+  return true;
+}
+export {
+  validateEach,
+  InvalidDecoratorItemException
+};

package/dist/hooks/before-app-shutdown.hook.js

@@ -0,0 +1,43 @@
+import { createRequire } from "node:module";
+var __legacyDecorateClassTS = function(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;
+};
+var __legacyDecorateParamTS = (index, decorator) => (target, key) => decorator(target, key, index);
+var __legacyMetadataTS = (k, v) => {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function")
+    return Reflect.metadata(k, v);
+};
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+// packages/core/src/hooks/before-app-shutdown.hook.ts
+import { getNonTransientInstances, getTransientInstances } from "../helpers/transient.helper.js";
+import { isFunction, isNull } from "../helpers/shared.helper.js";
+function hasBeforeApplicationShutdownHook(instance) {
+  return isFunction(instance.beforeApplicationShutdown);
+}
+function callOperator(instances, signal) {
+  return instances.filter((instance) => !isNull(instance)).filter(hasBeforeApplicationShutdownHook).map(async (instance) => instance.beforeApplicationShutdown(signal));
+}
+async function callBeforeAppShutdownHook(module, signal) {
+  const providers = module.getNonAliasProviders();
+  const [, moduleClassHost] = providers.shift();
+  const instances = [...providers, ...module.injectables];
+  const nonTransientInstances = getNonTransientInstances(instances);
+  await Promise.all(callOperator(nonTransientInstances, signal));
+  const transientInstances = getTransientInstances(instances);
+  await Promise.all(callOperator(transientInstances, signal));
+  const moduleClassInstance = moduleClassHost.instance;
+  if (moduleClassInstance && hasBeforeApplicationShutdownHook(moduleClassInstance) && moduleClassHost.isDependencyTreeStatic()) {
+    await moduleClassInstance.beforeApplicationShutdown(signal);
+  }
+}
+export {
+  callBeforeAppShutdownHook
+};

package/dist/hooks/on-app-bootstrap.hook.js

@@ -0,0 +1,43 @@
+import { createRequire } from "node:module";
+var __legacyDecorateClassTS = function(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;
+};
+var __legacyDecorateParamTS = (index, decorator) => (target, key) => decorator(target, key, index);
+var __legacyMetadataTS = (k, v) => {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function")
+    return Reflect.metadata(k, v);
+};
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+// packages/core/src/hooks/on-app-bootstrap.hook.ts
+import { getNonTransientInstances, getTransientInstances } from "../helpers/transient.helper.js";
+import { isFunction, isNull } from "../helpers/shared.helper.js";
+function hasOnAppBootstrapHook(instance) {
+  return isFunction(instance.onApplicationBootstrap);
+}
+function callOperator(instances) {
+  return instances.filter((instance) => !isNull(instance)).filter(hasOnAppBootstrapHook).map(async (instance) => instance.onApplicationBootstrap());
+}
+async function callModuleBootstrapHook(module) {
+  const providers = module.getNonAliasProviders();
+  const [, moduleClassHost] = providers.shift();
+  const instances = [...providers, ...module.injectables];
+  const nonTransientInstances = getNonTransientInstances(instances);
+  await Promise.all(callOperator(nonTransientInstances));
+  const transientInstances = getTransientInstances(instances);
+  await Promise.all(callOperator(transientInstances));
+  const moduleClassInstance = moduleClassHost.instance;
+  if (moduleClassInstance && hasOnAppBootstrapHook(moduleClassInstance) && moduleClassHost.isDependencyTreeStatic()) {
+    await moduleClassInstance.onApplicationBootstrap();
+  }
+}
+export {
+  callModuleBootstrapHook
+};

package/dist/hooks/on-app-shutdown.hook.js

@@ -0,0 +1,43 @@
+import { createRequire } from "node:module";
+var __legacyDecorateClassTS = function(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;
+};
+var __legacyDecorateParamTS = (index, decorator) => (target, key) => decorator(target, key, index);
+var __legacyMetadataTS = (k, v) => {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function")
+    return Reflect.metadata(k, v);
+};
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+// packages/core/src/hooks/on-app-shutdown.hook.ts
+import { getNonTransientInstances, getTransientInstances } from "../helpers/transient.helper.js";
+import { isFunction, isNull } from "../helpers/shared.helper.js";
+function hasOnAppShutdownHook(instance) {
+  return isFunction(instance.onApplicationShutdown);
+}
+function callOperator(instances, signal) {
+  return instances.filter((instance) => !isNull(instance)).filter(hasOnAppShutdownHook).map(async (instance) => instance.onApplicationShutdown(signal));
+}
+async function callAppShutdownHook(module, signal) {
+  const providers = module.getNonAliasProviders();
+  const [, moduleClassHost] = providers.shift();
+  const instances = [...providers, ...module.injectables];
+  const nonTransientInstances = getNonTransientInstances(instances);
+  await Promise.all(callOperator(nonTransientInstances, signal));
+  const transientInstances = getTransientInstances(instances);
+  await Promise.all(callOperator(transientInstances, signal));
+  const moduleClassInstance = moduleClassHost.instance;
+  if (moduleClassInstance && hasOnAppShutdownHook(moduleClassInstance) && moduleClassHost.isDependencyTreeStatic()) {
+    await moduleClassInstance.onApplicationShutdown(signal);
+  }
+}
+export {
+  callAppShutdownHook
+};

package/dist/hooks/on-module-destroy.hook.js

@@ -0,0 +1,43 @@
+import { createRequire } from "node:module";
+var __legacyDecorateClassTS = function(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;
+};
+var __legacyDecorateParamTS = (index, decorator) => (target, key) => decorator(target, key, index);
+var __legacyMetadataTS = (k, v) => {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function")
+    return Reflect.metadata(k, v);
+};
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+// packages/core/src/hooks/on-module-destroy.hook.ts
+import { getNonTransientInstances, getTransientInstances } from "../helpers/transient.helper.js";
+import { isFunction, isNull } from "../helpers/shared.helper.js";
+function hasOnModuleDestroyHook(instance) {
+  return isFunction(instance.onModuleDestroy);
+}
+function callOperator(instances) {
+  return instances.filter((instance) => !isNull(instance)).filter(hasOnModuleDestroyHook).map(async (instance) => instance.onModuleDestroy());
+}
+async function callModuleDestroyHook(module) {
+  const providers = module.getNonAliasProviders();
+  const [, moduleClassHost] = providers.shift();
+  const instances = [...providers, ...module.injectables];
+  const nonTransientInstances = getNonTransientInstances(instances);
+  await Promise.all(callOperator(nonTransientInstances));
+  const transientInstances = getTransientInstances(instances);
+  await Promise.all(callOperator(transientInstances));
+  const moduleClassInstance = moduleClassHost.instance;
+  if (moduleClassInstance && hasOnModuleDestroyHook(moduleClassInstance) && moduleClassHost.isDependencyTreeStatic()) {
+    await moduleClassInstance.onModuleDestroy();
+  }
+}
+export {
+  callModuleDestroyHook
+};

package/dist/hooks/on-module-init.hook.js

@@ -0,0 +1,43 @@
+import { createRequire } from "node:module";
+var __legacyDecorateClassTS = function(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;
+};
+var __legacyDecorateParamTS = (index, decorator) => (target, key) => decorator(target, key, index);
+var __legacyMetadataTS = (k, v) => {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function")
+    return Reflect.metadata(k, v);
+};
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+// packages/core/src/hooks/on-module-init.hook.ts
+import { getNonTransientInstances, getTransientInstances } from "../helpers/transient.helper.js";
+import { isFunction, isNull } from "../helpers/shared.helper.js";
+function hasOnModuleInitHook(instance) {
+  return isFunction(instance.onModuleInit);
+}
+function callOperator(instances) {
+  return instances.filter((instance) => !isNull(instance)).filter(hasOnModuleInitHook).map(async (instance) => instance.onModuleInit());
+}
+async function callModuleInitHook(module) {
+  const providers = module.getNonAliasProviders();
+  const [, moduleClassHost] = providers.shift();
+  const instances = [...providers, ...module.injectables];
+  const nonTransientInstances = getNonTransientInstances(instances);
+  await Promise.all(callOperator(nonTransientInstances));
+  const transientInstances = getTransientInstances(instances);
+  await Promise.all(callOperator(transientInstances));
+  const moduleClassInstance = moduleClassHost.instance;
+  if (moduleClassInstance && hasOnModuleInitHook(moduleClassInstance) && moduleClassHost.isDependencyTreeStatic()) {
+    await moduleClassInstance.onModuleInit();
+  }
+}
+export {
+  callModuleInitHook
+};