@adaas/a-utils 0.2.8 → 0.3.1

package/dist/node/lib/A-Logger/A-Logger.env.d.mts

@@ -0,0 +1,30 @@
+declare const A_LoggerEnvVariables: {
+    /**
+     * Sets the log level for the logger
+     *
+     * @example 'debug', 'info', 'warn', 'error'
+     */
+    readonly A_LOGGER_LEVEL: "A_LOGGER_LEVEL";
+    /**
+     * Sets the default scope length for log messages
+     *
+     * @example 'A_LOGGER_DEFAULT_SCOPE_LENGTH'
+     */
+    readonly A_LOGGER_DEFAULT_SCOPE_LENGTH: "A_LOGGER_DEFAULT_SCOPE_LENGTH";
+    /**
+     * Sets the default color for scope display in log messages
+     *
+     * @example 'green', 'blue', 'red', 'yellow', 'gray', 'magenta', 'cyan', 'white', 'pink'
+     */
+    readonly A_LOGGER_DEFAULT_SCOPE_COLOR: "A_LOGGER_DEFAULT_SCOPE_COLOR";
+    /**
+     * Sets the default color for log message content
+     *
+     * @example 'green', 'blue', 'red', 'yellow', 'gray', 'magenta', 'cyan', 'white', 'pink'
+     */
+    readonly A_LOGGER_DEFAULT_LOG_COLOR: "A_LOGGER_DEFAULT_LOG_COLOR";
+};
+declare const A_LoggerEnvVariablesArray: readonly ["A_LOGGER_LEVEL", "A_LOGGER_DEFAULT_SCOPE_LENGTH", "A_LOGGER_DEFAULT_SCOPE_COLOR", "A_LOGGER_DEFAULT_LOG_COLOR"];
+type A_LoggerEnvVariablesType = (typeof A_LoggerEnvVariables)[keyof typeof A_LoggerEnvVariables][];
+
+export { A_LoggerEnvVariables, A_LoggerEnvVariablesArray, type A_LoggerEnvVariablesType };

package/dist/node/lib/A-Logger/A-Logger.env.d.ts

@@ -0,0 +1,30 @@
+declare const A_LoggerEnvVariables: {
+    /**
+     * Sets the log level for the logger
+     *
+     * @example 'debug', 'info', 'warn', 'error'
+     */
+    readonly A_LOGGER_LEVEL: "A_LOGGER_LEVEL";
+    /**
+     * Sets the default scope length for log messages
+     *
+     * @example 'A_LOGGER_DEFAULT_SCOPE_LENGTH'
+     */
+    readonly A_LOGGER_DEFAULT_SCOPE_LENGTH: "A_LOGGER_DEFAULT_SCOPE_LENGTH";
+    /**
+     * Sets the default color for scope display in log messages
+     *
+     * @example 'green', 'blue', 'red', 'yellow', 'gray', 'magenta', 'cyan', 'white', 'pink'
+     */
+    readonly A_LOGGER_DEFAULT_SCOPE_COLOR: "A_LOGGER_DEFAULT_SCOPE_COLOR";
+    /**
+     * Sets the default color for log message content
+     *
+     * @example 'green', 'blue', 'red', 'yellow', 'gray', 'magenta', 'cyan', 'white', 'pink'
+     */
+    readonly A_LOGGER_DEFAULT_LOG_COLOR: "A_LOGGER_DEFAULT_LOG_COLOR";
+};
+declare const A_LoggerEnvVariablesArray: readonly ["A_LOGGER_LEVEL", "A_LOGGER_DEFAULT_SCOPE_LENGTH", "A_LOGGER_DEFAULT_SCOPE_COLOR", "A_LOGGER_DEFAULT_LOG_COLOR"];
+type A_LoggerEnvVariablesType = (typeof A_LoggerEnvVariables)[keyof typeof A_LoggerEnvVariables][];
+
+export { A_LoggerEnvVariables, A_LoggerEnvVariablesArray, type A_LoggerEnvVariablesType };

package/dist/node/lib/A-Logger/A-Logger.env.js

@@ -0,0 +1,39 @@
+'use strict';
+
+const A_LoggerEnvVariables = {
+  /**
+   * Sets the log level for the logger
+   * 
+   * @example 'debug', 'info', 'warn', 'error'
+   */
+  A_LOGGER_LEVEL: "A_LOGGER_LEVEL",
+  /**     
+   * Sets the default scope length for log messages
+   * 
+   * @example 'A_LOGGER_DEFAULT_SCOPE_LENGTH'
+   */
+  A_LOGGER_DEFAULT_SCOPE_LENGTH: "A_LOGGER_DEFAULT_SCOPE_LENGTH",
+  /**
+   * Sets the default color for scope display in log messages
+   * 
+   * @example 'green', 'blue', 'red', 'yellow', 'gray', 'magenta', 'cyan', 'white', 'pink'
+   */
+  A_LOGGER_DEFAULT_SCOPE_COLOR: "A_LOGGER_DEFAULT_SCOPE_COLOR",
+  /**
+   * Sets the default color for log message content
+   * 
+   * @example 'green', 'blue', 'red', 'yellow', 'gray', 'magenta', 'cyan', 'white', 'pink'
+   */
+  A_LOGGER_DEFAULT_LOG_COLOR: "A_LOGGER_DEFAULT_LOG_COLOR"
+};
+const A_LoggerEnvVariablesArray = [
+  A_LoggerEnvVariables.A_LOGGER_LEVEL,
+  A_LoggerEnvVariables.A_LOGGER_DEFAULT_SCOPE_LENGTH,
+  A_LoggerEnvVariables.A_LOGGER_DEFAULT_SCOPE_COLOR,
+  A_LoggerEnvVariables.A_LOGGER_DEFAULT_LOG_COLOR
+];
+
+exports.A_LoggerEnvVariables = A_LoggerEnvVariables;
+exports.A_LoggerEnvVariablesArray = A_LoggerEnvVariablesArray;
+//# sourceMappingURL=A-Logger.env.js.map
+//# sourceMappingURL=A-Logger.env.js.map

package/dist/node/lib/A-Logger/A-Logger.env.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/lib/A-Logger/A-Logger.env.ts"],"names":[],"mappings":";;AAEO,MAAM,oBAAA,GAAuB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAMhC,cAAA,EAAgB,gBAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOhB,6BAAA,EAA+B,+BAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAO/B,4BAAA,EAA8B,8BAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAO9B,0BAAA,EAA4B;AAChC;AAIO,MAAM,yBAAA,GAA4B;AAAA,EACrC,oBAAA,CAAqB,cAAA;AAAA,EACrB,oBAAA,CAAqB,6BAAA;AAAA,EACrB,oBAAA,CAAqB,4BAAA;AAAA,EACrB,oBAAA,CAAqB;AACzB","file":"A-Logger.env.js","sourcesContent":["\n\nexport const A_LoggerEnvVariables = {\n    /**\n     * Sets the log level for the logger\n     * \n     * @example 'debug', 'info', 'warn', 'error'\n     */\n    A_LOGGER_LEVEL: 'A_LOGGER_LEVEL',\n\n    /**     \n     * Sets the default scope length for log messages\n     * \n     * @example 'A_LOGGER_DEFAULT_SCOPE_LENGTH'\n     */\n    A_LOGGER_DEFAULT_SCOPE_LENGTH: 'A_LOGGER_DEFAULT_SCOPE_LENGTH',\n\n    /**\n     * Sets the default color for scope display in log messages\n     * \n     * @example 'green', 'blue', 'red', 'yellow', 'gray', 'magenta', 'cyan', 'white', 'pink'\n     */\n    A_LOGGER_DEFAULT_SCOPE_COLOR: 'A_LOGGER_DEFAULT_SCOPE_COLOR',\n\n    /**\n     * Sets the default color for log message content\n     * \n     * @example 'green', 'blue', 'red', 'yellow', 'gray', 'magenta', 'cyan', 'white', 'pink'\n     */\n    A_LOGGER_DEFAULT_LOG_COLOR: 'A_LOGGER_DEFAULT_LOG_COLOR',\n} as const;\n\n\n\nexport const A_LoggerEnvVariablesArray = [\n    A_LoggerEnvVariables.A_LOGGER_LEVEL,\n    A_LoggerEnvVariables.A_LOGGER_DEFAULT_SCOPE_LENGTH,\n    A_LoggerEnvVariables.A_LOGGER_DEFAULT_SCOPE_COLOR,\n    A_LoggerEnvVariables.A_LOGGER_DEFAULT_LOG_COLOR,\n] as const;\n\n\nexport type A_LoggerEnvVariablesType = (typeof A_LoggerEnvVariables)[keyof typeof A_LoggerEnvVariables][];"]}

package/dist/node/lib/A-Logger/A-Logger.env.mjs

@@ -0,0 +1,38 @@
+import '../../chunk-EQQGB2QZ.mjs';
+
+const A_LoggerEnvVariables = {
+  /**
+   * Sets the log level for the logger
+   * 
+   * @example 'debug', 'info', 'warn', 'error'
+   */
+  A_LOGGER_LEVEL: "A_LOGGER_LEVEL",
+  /**     
+   * Sets the default scope length for log messages
+   * 
+   * @example 'A_LOGGER_DEFAULT_SCOPE_LENGTH'
+   */
+  A_LOGGER_DEFAULT_SCOPE_LENGTH: "A_LOGGER_DEFAULT_SCOPE_LENGTH",
+  /**
+   * Sets the default color for scope display in log messages
+   * 
+   * @example 'green', 'blue', 'red', 'yellow', 'gray', 'magenta', 'cyan', 'white', 'pink'
+   */
+  A_LOGGER_DEFAULT_SCOPE_COLOR: "A_LOGGER_DEFAULT_SCOPE_COLOR",
+  /**
+   * Sets the default color for log message content
+   * 
+   * @example 'green', 'blue', 'red', 'yellow', 'gray', 'magenta', 'cyan', 'white', 'pink'
+   */
+  A_LOGGER_DEFAULT_LOG_COLOR: "A_LOGGER_DEFAULT_LOG_COLOR"
+};
+const A_LoggerEnvVariablesArray = [
+  A_LoggerEnvVariables.A_LOGGER_LEVEL,
+  A_LoggerEnvVariables.A_LOGGER_DEFAULT_SCOPE_LENGTH,
+  A_LoggerEnvVariables.A_LOGGER_DEFAULT_SCOPE_COLOR,
+  A_LoggerEnvVariables.A_LOGGER_DEFAULT_LOG_COLOR
+];
+
+export { A_LoggerEnvVariables, A_LoggerEnvVariablesArray };
+//# sourceMappingURL=A-Logger.env.mjs.map
+//# sourceMappingURL=A-Logger.env.mjs.map

package/dist/node/lib/A-Logger/A-Logger.env.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/lib/A-Logger/A-Logger.env.ts"],"names":[],"mappings":";;AAEO,MAAM,oBAAA,GAAuB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAMhC,cAAA,EAAgB,gBAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOhB,6BAAA,EAA+B,+BAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAO/B,4BAAA,EAA8B,8BAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAO9B,0BAAA,EAA4B;AAChC;AAIO,MAAM,yBAAA,GAA4B;AAAA,EACrC,oBAAA,CAAqB,cAAA;AAAA,EACrB,oBAAA,CAAqB,6BAAA;AAAA,EACrB,oBAAA,CAAqB,4BAAA;AAAA,EACrB,oBAAA,CAAqB;AACzB","file":"A-Logger.env.mjs","sourcesContent":["\n\nexport const A_LoggerEnvVariables = {\n    /**\n     * Sets the log level for the logger\n     * \n     * @example 'debug', 'info', 'warn', 'error'\n     */\n    A_LOGGER_LEVEL: 'A_LOGGER_LEVEL',\n\n    /**     \n     * Sets the default scope length for log messages\n     * \n     * @example 'A_LOGGER_DEFAULT_SCOPE_LENGTH'\n     */\n    A_LOGGER_DEFAULT_SCOPE_LENGTH: 'A_LOGGER_DEFAULT_SCOPE_LENGTH',\n\n    /**\n     * Sets the default color for scope display in log messages\n     * \n     * @example 'green', 'blue', 'red', 'yellow', 'gray', 'magenta', 'cyan', 'white', 'pink'\n     */\n    A_LOGGER_DEFAULT_SCOPE_COLOR: 'A_LOGGER_DEFAULT_SCOPE_COLOR',\n\n    /**\n     * Sets the default color for log message content\n     * \n     * @example 'green', 'blue', 'red', 'yellow', 'gray', 'magenta', 'cyan', 'white', 'pink'\n     */\n    A_LOGGER_DEFAULT_LOG_COLOR: 'A_LOGGER_DEFAULT_LOG_COLOR',\n} as const;\n\n\n\nexport const A_LoggerEnvVariablesArray = [\n    A_LoggerEnvVariables.A_LOGGER_LEVEL,\n    A_LoggerEnvVariables.A_LOGGER_DEFAULT_SCOPE_LENGTH,\n    A_LoggerEnvVariables.A_LOGGER_DEFAULT_SCOPE_COLOR,\n    A_LoggerEnvVariables.A_LOGGER_DEFAULT_LOG_COLOR,\n] as const;\n\n\nexport type A_LoggerEnvVariablesType = (typeof A_LoggerEnvVariables)[keyof typeof A_LoggerEnvVariables][];"]}

package/dist/node/lib/A-Logger/A-Logger.types.d.mts

@@ -0,0 +1,8 @@
+type A_LoggerLevel = 'debug' | 'info' | 'warn' | 'error' | 'all';
+/**
+ * Available color names for the logger
+ * Can be used as first parameter in logging methods to specify message color
+ */
+type A_LoggerColorName = 'red' | 'yellow' | 'green' | 'blue' | 'cyan' | 'magenta' | 'gray' | 'brightBlue' | 'brightCyan' | 'brightMagenta' | 'darkGray' | 'lightGray' | 'indigo' | 'violet' | 'purple' | 'lavender' | 'skyBlue' | 'steelBlue' | 'slateBlue' | 'deepBlue' | 'lightBlue' | 'periwinkle' | 'cornflower' | 'powder' | 'charcoal' | 'silver' | 'smoke' | 'slate';
+
+export type { A_LoggerColorName, A_LoggerLevel };

package/dist/node/lib/A-Logger/A-Logger.types.d.ts

@@ -0,0 +1,8 @@
+type A_LoggerLevel = 'debug' | 'info' | 'warn' | 'error' | 'all';
+/**
+ * Available color names for the logger
+ * Can be used as first parameter in logging methods to specify message color
+ */
+type A_LoggerColorName = 'red' | 'yellow' | 'green' | 'blue' | 'cyan' | 'magenta' | 'gray' | 'brightBlue' | 'brightCyan' | 'brightMagenta' | 'darkGray' | 'lightGray' | 'indigo' | 'violet' | 'purple' | 'lavender' | 'skyBlue' | 'steelBlue' | 'slateBlue' | 'deepBlue' | 'lightBlue' | 'periwinkle' | 'cornflower' | 'powder' | 'charcoal' | 'silver' | 'smoke' | 'slate';
+
+export type { A_LoggerColorName, A_LoggerLevel };

package/dist/node/lib/A-Logger/A-Logger.types.js

@@ -0,0 +1,4 @@
+'use strict';
+
+//# sourceMappingURL=A-Logger.types.js.map
+//# sourceMappingURL=A-Logger.types.js.map

package/dist/node/lib/A-Logger/A-Logger.types.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"A-Logger.types.js"}

package/dist/node/lib/A-Logger/A-Logger.types.mjs

@@ -0,0 +1,3 @@
+
+//# sourceMappingURL=A-Logger.types.mjs.map
+//# sourceMappingURL=A-Logger.types.mjs.map

package/dist/node/lib/A-Logger/A-Logger.types.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"A-Logger.types.mjs"}

package/dist/node/lib/A-Logger/index.d.mts

@@ -0,0 +1,9 @@
+export { A_Logger } from './A-Logger.component.mjs';
+export { A_LoggerColorName, A_LoggerLevel } from './A-Logger.types.mjs';
+export { A_LOGGER_ANSI, A_LOGGER_COLORS, A_LOGGER_DEFAULT_LEVEL, A_LOGGER_DEFAULT_SCOPE_LENGTH, A_LOGGER_ENV_KEYS, A_LOGGER_FORMAT, A_LOGGER_SAFE_RANDOM_COLORS, A_LOGGER_TERMINAL, A_LOGGER_TIME_FORMAT } from './A-Logger.constants.mjs';
+export { A_LoggerEnvVariables, A_LoggerEnvVariablesArray, A_LoggerEnvVariablesType } from './A-Logger.env.mjs';
+import '@adaas/a-concept';
+import '../A-Config/A-Config.context.mjs';
+import '../A-Config/A-Config.types.mjs';
+import '../A-Execution/A-Execution.context.mjs';
+import '../A-Config/A-Config.constants.mjs';

package/dist/node/lib/A-Logger/index.d.ts

@@ -0,0 +1,9 @@
+export { A_Logger } from './A-Logger.component.js';
+export { A_LoggerColorName, A_LoggerLevel } from './A-Logger.types.js';
+export { A_LOGGER_ANSI, A_LOGGER_COLORS, A_LOGGER_DEFAULT_LEVEL, A_LOGGER_DEFAULT_SCOPE_LENGTH, A_LOGGER_ENV_KEYS, A_LOGGER_FORMAT, A_LOGGER_SAFE_RANDOM_COLORS, A_LOGGER_TERMINAL, A_LOGGER_TIME_FORMAT } from './A-Logger.constants.js';
+export { A_LoggerEnvVariables, A_LoggerEnvVariablesArray, A_LoggerEnvVariablesType } from './A-Logger.env.js';
+import '@adaas/a-concept';
+import '../A-Config/A-Config.context.js';
+import '../A-Config/A-Config.types.js';
+import '../A-Execution/A-Execution.context.js';
+import '../A-Config/A-Config.constants.js';

package/dist/node/lib/A-Logger/index.js

@@ -0,0 +1,35 @@
+'use strict';
+
+var ALogger_component = require('./A-Logger.component');
+var ALogger_types = require('./A-Logger.types');
+var ALogger_constants = require('./A-Logger.constants');
+var ALogger_env = require('./A-Logger.env');
+
+
+
+Object.keys(ALogger_component).forEach(function (k) {
+	if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
+		enumerable: true,
+		get: function () { return ALogger_component[k]; }
+	});
+});
+Object.keys(ALogger_types).forEach(function (k) {
+	if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
+		enumerable: true,
+		get: function () { return ALogger_types[k]; }
+	});
+});
+Object.keys(ALogger_constants).forEach(function (k) {
+	if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
+		enumerable: true,
+		get: function () { return ALogger_constants[k]; }
+	});
+});
+Object.keys(ALogger_env).forEach(function (k) {
+	if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
+		enumerable: true,
+		get: function () { return ALogger_env[k]; }
+	});
+});
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map

package/dist/node/lib/A-Logger/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"index.js","sourcesContent":[]}

package/dist/node/lib/A-Logger/index.mjs

@@ -0,0 +1,6 @@
+export * from './A-Logger.component';
+export * from './A-Logger.types';
+export * from './A-Logger.constants';
+export * from './A-Logger.env';
+//# sourceMappingURL=index.mjs.map
+//# sourceMappingURL=index.mjs.map

package/dist/node/lib/A-Logger/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"index.mjs","sourcesContent":[]}

package/dist/node/lib/A-Manifest/A-Manifest.context.d.mts

@@ -0,0 +1,3 @@
+import '@adaas/a-concept';
+import './A-Manifest.types.mjs';
+export { A as A_Manifest } from '../../A-Manifest.context-D2uynD9t.mjs';

package/dist/node/lib/A-Manifest/A-Manifest.context.d.ts

@@ -0,0 +1,3 @@
+import '@adaas/a-concept';
+import './A-Manifest.types.js';
+export { A as A_Manifest } from '../../A-Manifest.context-rZnvR17w.js';

package/dist/node/lib/A-Manifest/A-Manifest.context.js

@@ -0,0 +1,164 @@
+'use strict';
+
+var aConcept = require('@adaas/a-concept');
+var AManifest_error = require('./A-Manifest.error');
+var AManifestChecker_class = require('./classes/A-ManifestChecker.class');
+var aFrame = require('@adaas/a-frame');
+
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __decorateClass = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (decorator(result)) || result;
+  return result;
+};
+exports.A_Manifest = class A_Manifest extends aConcept.A_Fragment {
+  /**
+   * A-Manifest is a configuration set that allows to include or exclude component application for the particular methods.
+   *
+   * For example, if A-Scope provides polymorphic A-Component that applies for All A-Entities in it but you have another component that should be used for only One particular Entity, you can use A-Manifest to specify this behavior.
+   * 
+   * 
+   * By default if Component is provided in the scope - it applies for all entities in it. However, if you want to exclude some entities or include only some entities for the particular component - you can use A-Manifest to define this behavior.
+   * 
+   * @param config - Array of component configurations
+   */
+  constructor(config = []) {
+    super({
+      name: "A-Manifest"
+    });
+    this.rules = [];
+    this.prepare(config);
+  }
+  /**
+   * Should convert received configuration into internal Regexp applicable for internal storage
+   */
+  prepare(config) {
+    if (!aConcept.A_TypeGuards.isArray(config))
+      throw new AManifest_error.A_ManifestError(
+        AManifest_error.A_ManifestError.ManifestInitializationError,
+        `A-Manifest configuration should be an array of configurations`
+      );
+    for (const item of config) {
+      this.processConfigItem(item);
+    }
+  }
+  /**
+   * Process a single configuration item and convert it to internal rules
+   */
+  processConfigItem(item) {
+    if (!aConcept.A_TypeGuards.isComponentConstructor(item.component))
+      throw new AManifest_error.A_ManifestError(
+        AManifest_error.A_ManifestError.ManifestInitializationError,
+        `A-Manifest configuration item should be a A-Component constructor`
+      );
+    const componentRegex = this.constructorToRegex(item.component);
+    if (item.apply || item.exclude) {
+      const methodRegex = /.*/;
+      this.rules.push({
+        componentRegex,
+        methodRegex,
+        applyRegex: item.apply ? this.allowedComponentsToRegex(item.apply) : void 0,
+        excludeRegex: item.exclude ? this.allowedComponentsToRegex(item.exclude) : void 0
+      });
+    }
+    if (item.methods && item.methods.length > 0) {
+      for (const methodConfig of item.methods) {
+        const methodRegex = this.methodToRegex(methodConfig.method);
+        this.rules.push({
+          componentRegex,
+          methodRegex,
+          applyRegex: methodConfig.apply ? this.allowedComponentsToRegex(methodConfig.apply) : void 0,
+          excludeRegex: methodConfig.exclude ? this.allowedComponentsToRegex(methodConfig.exclude) : void 0
+        });
+      }
+    }
+  }
+  /**
+   * Convert a constructor to a regex pattern
+   */
+  constructorToRegex(ctor) {
+    return new RegExp(`^${this.escapeRegex(ctor.name)}$`);
+  }
+  /**
+   * Convert a method name or regex to a regex pattern
+   */
+  methodToRegex(method) {
+    if (method instanceof RegExp) {
+      return method;
+    }
+    return new RegExp(`^${this.escapeRegex(method)}$`);
+  }
+  /**
+   * Convert allowed components array or regex to a single regex
+   */
+  allowedComponentsToRegex(components) {
+    if (components instanceof RegExp) {
+      return components;
+    }
+    const patterns = components.map((ctor) => this.escapeRegex(ctor.name));
+    return new RegExp(`^(${patterns.join("|")})$`);
+  }
+  /**
+   * Escape special regex characters in a string
+   */
+  escapeRegex(str) {
+    return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  }
+  configItemToRegexp(item) {
+    return this.constructorToRegex(item);
+  }
+  ID(component, method) {
+    return `${component.name}.${method}`;
+  }
+  /**
+   * Check if a component and method combination is allowed for a target
+   */
+  isAllowed(ctor, method) {
+    const componentCtor = typeof ctor === "function" ? ctor : ctor.constructor;
+    return new AManifestChecker_class.A_ManifestChecker(this, componentCtor, method);
+  }
+  /**
+   * Internal method to check if access is allowed
+   */
+  internal_checkAccess(query) {
+    const componentName = query.component.name;
+    const methodName = query.method;
+    const targetName = query.target.name;
+    const matchingRules = this.rules.filter(
+      (rule) => rule.componentRegex.test(componentName) && rule.methodRegex.test(methodName)
+    ).sort((a, b) => {
+      const aIsGeneral = a.methodRegex.source === ".*";
+      const bIsGeneral = b.methodRegex.source === ".*";
+      if (aIsGeneral && !bIsGeneral) return 1;
+      if (!aIsGeneral && bIsGeneral) return -1;
+      return 0;
+    });
+    if (matchingRules.length === 0) {
+      return true;
+    }
+    for (const rule of matchingRules) {
+      if (rule.excludeRegex && rule.excludeRegex.test(targetName)) {
+        return false;
+      }
+      if (rule.applyRegex) {
+        return rule.applyRegex.test(targetName);
+      }
+    }
+    return true;
+  }
+  isExcluded(ctor, method) {
+    const componentCtor = typeof ctor === "function" ? ctor : ctor.constructor;
+    return new AManifestChecker_class.A_ManifestChecker(this, componentCtor, method, true);
+  }
+};
+exports.A_Manifest = __decorateClass([
+  aFrame.A_Frame.Fragment({
+    namespace: "A-Utils",
+    name: "A-Manifest",
+    description: "A-Manifest is a configuration fragment that allows to include or exclude component application for particular methods. It provides fine-grained control over which components are applied to which targets and methods within the application, enabling flexible and dynamic behavior based on defined rules."
+  })
+], exports.A_Manifest);
+//# sourceMappingURL=A-Manifest.context.js.map
+//# sourceMappingURL=A-Manifest.context.js.map

package/dist/node/lib/A-Manifest/A-Manifest.context.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/lib/A-Manifest/A-Manifest.context.ts"],"names":["A_Manifest","A_Fragment","A_TypeGuards","A_ManifestError","A_ManifestChecker","A_Frame"],"mappings":"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","file":"A-Manifest.context.js","sourcesContent":["import { A_Component, A_Fragment, A_TypeGuards, A_TYPES__Component_Constructor } from \"@adaas/a-concept\";\nimport { A_UTILS_TYPES__Manifest_Init, A_UTILS_TYPES__Manifest_ComponentLevelConfig, A_UTILS_TYPES__Manifest_AllowedComponents, A_UTILS_TYPES__ManifestRule, A_UTILS_TYPES__ManifestQuery } from \"./A-Manifest.types\";\nimport { A_ManifestError } from \"./A-Manifest.error\";\nimport { A_ManifestChecker } from \"./classes/A-ManifestChecker.class\";\nimport { A_Frame } from \"@adaas/a-frame\";\n\n\n\n\n\n@A_Frame.Fragment({\n    namespace: 'A-Utils',\n    name: 'A-Manifest',\n    description: 'A-Manifest is a configuration fragment that allows to include or exclude component application for particular methods. It provides fine-grained control over which components are applied to which targets and methods within the application, enabling flexible and dynamic behavior based on defined rules.'\n})\nexport class A_Manifest extends A_Fragment {\n\n    private rules: A_UTILS_TYPES__ManifestRule[] = [];\n\n    /**\n     * A-Manifest is a configuration set that allows to include or exclude component application for the particular methods.\n     *\n     * For example, if A-Scope provides polymorphic A-Component that applies for All A-Entities in it but you have another component that should be used for only One particular Entity, you can use A-Manifest to specify this behavior.\n     * \n     * \n     * By default if Component is provided in the scope - it applies for all entities in it. However, if you want to exclude some entities or include only some entities for the particular component - you can use A-Manifest to define this behavior.\n     * \n     * @param config - Array of component configurations\n     */\n    constructor(config: A_UTILS_TYPES__Manifest_Init = []) {\n        super({\n            name: 'A-Manifest',\n        });\n\n        this.prepare(config);\n    }\n\n\n    /**\n     * Should convert received configuration into internal Regexp applicable for internal storage\n     */\n    protected prepare(config: A_UTILS_TYPES__Manifest_Init) {\n        if (!A_TypeGuards.isArray(config))\n            throw new A_ManifestError(\n                A_ManifestError.ManifestInitializationError,\n                `A-Manifest configuration should be an array of configurations`\n            );\n\n        for (const item of config) {\n            this.processConfigItem(item);\n        }\n    }\n\n    /**\n     * Process a single configuration item and convert it to internal rules\n     */\n    private processConfigItem(item: A_UTILS_TYPES__Manifest_ComponentLevelConfig) {\n        if (!A_TypeGuards.isComponentConstructor(item.component))\n            throw new A_ManifestError(\n                A_ManifestError.ManifestInitializationError,\n                `A-Manifest configuration item should be a A-Component constructor`\n            );\n\n        const componentRegex = this.constructorToRegex(item.component);\n\n        // Always add component-level rule first (applies to all methods)\n        if (item.apply || item.exclude) {\n            const methodRegex = /.*/; // Match all methods\n\n            this.rules.push({\n                componentRegex,\n                methodRegex,\n                applyRegex: item.apply ? this.allowedComponentsToRegex(item.apply) : undefined,\n                excludeRegex: item.exclude ? this.allowedComponentsToRegex(item.exclude) : undefined,\n            });\n        }\n\n        // Then add method-level configurations (these will override component-level)\n        if (item.methods && item.methods.length > 0) {\n            for (const methodConfig of item.methods) {\n                const methodRegex = this.methodToRegex(methodConfig.method);\n\n                this.rules.push({\n                    componentRegex,\n                    methodRegex,\n                    applyRegex: methodConfig.apply ? this.allowedComponentsToRegex(methodConfig.apply) : undefined,\n                    excludeRegex: methodConfig.exclude ? this.allowedComponentsToRegex(methodConfig.exclude) : undefined,\n                });\n            }\n        }\n    }\n\n\n\n    /**\n     * Convert a constructor to a regex pattern\n     */\n    private constructorToRegex(ctor: A_TYPES__Component_Constructor): RegExp {\n        return new RegExp(`^${this.escapeRegex(ctor.name)}$`);\n    }\n\n    /**\n     * Convert a method name or regex to a regex pattern\n     */\n    private methodToRegex(method: string | RegExp): RegExp {\n        if (method instanceof RegExp) {\n            return method;\n        }\n        return new RegExp(`^${this.escapeRegex(method as string)}$`);\n    }\n\n    /**\n     * Convert allowed components array or regex to a single regex\n     */\n    private allowedComponentsToRegex(components: A_UTILS_TYPES__Manifest_AllowedComponents[] | RegExp): RegExp {\n        if (components instanceof RegExp) {\n            return components;\n        }\n\n        const patterns = components.map(ctor => this.escapeRegex(ctor.name));\n        return new RegExp(`^(${patterns.join('|')})$`);\n    }\n\n    /**\n     * Escape special regex characters in a string\n     */\n    private escapeRegex(str: string): string {\n        return str.replace(/[.*+?^${}()|[\\]\\\\]/g, '\\\\$&');\n    }\n\n    protected configItemToRegexp(item: A_TYPES__Component_Constructor): RegExp {\n        return this.constructorToRegex(item);\n    }\n\n\n    protected ID(component: A_TYPES__Component_Constructor, method: string) {\n        return `${component.name}.${method}`;\n    }\n\n    /**\n     * Check if a component and method combination is allowed for a target\n     */\n    isAllowed<T extends A_Component>(\n        ctor: T | A_TYPES__Component_Constructor<T>,\n        method: string\n    ): A_ManifestChecker {\n        const componentCtor = typeof ctor === 'function' ? ctor : ctor.constructor as A_TYPES__Component_Constructor;\n        return new A_ManifestChecker(this, componentCtor, method);\n    }\n\n    /**\n     * Internal method to check if access is allowed\n     */\n    internal_checkAccess(query: A_UTILS_TYPES__ManifestQuery): boolean {\n        const componentName = query.component.name;\n        const methodName = query.method;\n        const targetName = query.target.name;\n\n        // Find matching rules, sorted by specificity (method-specific rules first)\n        const matchingRules = this.rules\n            .filter(rule =>\n                rule.componentRegex.test(componentName) &&\n                rule.methodRegex.test(methodName)\n            )\n            .sort((a, b) => {\n                // Method-specific rules (not .* pattern) should come before general rules\n                const aIsGeneral = a.methodRegex.source === '.*';\n                const bIsGeneral = b.methodRegex.source === '.*';\n\n                if (aIsGeneral && !bIsGeneral) return 1;  // b comes first\n                if (!aIsGeneral && bIsGeneral) return -1; // a comes first\n                return 0; // same priority\n            });\n\n        // If no rules match, allow by default\n        if (matchingRules.length === 0) {\n            return true;\n        }\n\n        // Process rules in order of specificity (most specific first)\n        for (const rule of matchingRules) {\n            // If this rule has an exclusion that matches, deny access\n            if (rule.excludeRegex && rule.excludeRegex.test(targetName)) {\n                return false;\n            }\n\n            // If this rule has an apply list, check if target is in it\n            if (rule.applyRegex) {\n                return rule.applyRegex.test(targetName);\n            }\n        }\n\n        // If we have rules but no specific apply/exclude, allow by default\n        return true;\n    }\n\n    isExcluded<T extends A_Component>(\n        ctor: T | A_TYPES__Component_Constructor<T>,\n        method: string\n    ): A_ManifestChecker {\n        const componentCtor = typeof ctor === 'function' ? ctor : ctor.constructor as A_TYPES__Component_Constructor;\n        return new A_ManifestChecker(this, componentCtor, method, true);\n    }\n}\n"]}

package/dist/node/lib/A-Manifest/A-Manifest.context.mjs

@@ -0,0 +1,157 @@
+import { __decorateClass } from '../../chunk-EQQGB2QZ.mjs';
+import { A_Fragment, A_TypeGuards } from '@adaas/a-concept';
+import { A_ManifestError } from './A-Manifest.error';
+import { A_ManifestChecker } from './classes/A-ManifestChecker.class';
+import { A_Frame } from '@adaas/a-frame';
+
+let A_Manifest = class extends A_Fragment {
+  /**
+   * A-Manifest is a configuration set that allows to include or exclude component application for the particular methods.
+   *
+   * For example, if A-Scope provides polymorphic A-Component that applies for All A-Entities in it but you have another component that should be used for only One particular Entity, you can use A-Manifest to specify this behavior.
+   * 
+   * 
+   * By default if Component is provided in the scope - it applies for all entities in it. However, if you want to exclude some entities or include only some entities for the particular component - you can use A-Manifest to define this behavior.
+   * 
+   * @param config - Array of component configurations
+   */
+  constructor(config = []) {
+    super({
+      name: "A-Manifest"
+    });
+    this.rules = [];
+    this.prepare(config);
+  }
+  /**
+   * Should convert received configuration into internal Regexp applicable for internal storage
+   */
+  prepare(config) {
+    if (!A_TypeGuards.isArray(config))
+      throw new A_ManifestError(
+        A_ManifestError.ManifestInitializationError,
+        `A-Manifest configuration should be an array of configurations`
+      );
+    for (const item of config) {
+      this.processConfigItem(item);
+    }
+  }
+  /**
+   * Process a single configuration item and convert it to internal rules
+   */
+  processConfigItem(item) {
+    if (!A_TypeGuards.isComponentConstructor(item.component))
+      throw new A_ManifestError(
+        A_ManifestError.ManifestInitializationError,
+        `A-Manifest configuration item should be a A-Component constructor`
+      );
+    const componentRegex = this.constructorToRegex(item.component);
+    if (item.apply || item.exclude) {
+      const methodRegex = /.*/;
+      this.rules.push({
+        componentRegex,
+        methodRegex,
+        applyRegex: item.apply ? this.allowedComponentsToRegex(item.apply) : void 0,
+        excludeRegex: item.exclude ? this.allowedComponentsToRegex(item.exclude) : void 0
+      });
+    }
+    if (item.methods && item.methods.length > 0) {
+      for (const methodConfig of item.methods) {
+        const methodRegex = this.methodToRegex(methodConfig.method);
+        this.rules.push({
+          componentRegex,
+          methodRegex,
+          applyRegex: methodConfig.apply ? this.allowedComponentsToRegex(methodConfig.apply) : void 0,
+          excludeRegex: methodConfig.exclude ? this.allowedComponentsToRegex(methodConfig.exclude) : void 0
+        });
+      }
+    }
+  }
+  /**
+   * Convert a constructor to a regex pattern
+   */
+  constructorToRegex(ctor) {
+    return new RegExp(`^${this.escapeRegex(ctor.name)}$`);
+  }
+  /**
+   * Convert a method name or regex to a regex pattern
+   */
+  methodToRegex(method) {
+    if (method instanceof RegExp) {
+      return method;
+    }
+    return new RegExp(`^${this.escapeRegex(method)}$`);
+  }
+  /**
+   * Convert allowed components array or regex to a single regex
+   */
+  allowedComponentsToRegex(components) {
+    if (components instanceof RegExp) {
+      return components;
+    }
+    const patterns = components.map((ctor) => this.escapeRegex(ctor.name));
+    return new RegExp(`^(${patterns.join("|")})$`);
+  }
+  /**
+   * Escape special regex characters in a string
+   */
+  escapeRegex(str) {
+    return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  }
+  configItemToRegexp(item) {
+    return this.constructorToRegex(item);
+  }
+  ID(component, method) {
+    return `${component.name}.${method}`;
+  }
+  /**
+   * Check if a component and method combination is allowed for a target
+   */
+  isAllowed(ctor, method) {
+    const componentCtor = typeof ctor === "function" ? ctor : ctor.constructor;
+    return new A_ManifestChecker(this, componentCtor, method);
+  }
+  /**
+   * Internal method to check if access is allowed
+   */
+  internal_checkAccess(query) {
+    const componentName = query.component.name;
+    const methodName = query.method;
+    const targetName = query.target.name;
+    const matchingRules = this.rules.filter(
+      (rule) => rule.componentRegex.test(componentName) && rule.methodRegex.test(methodName)
+    ).sort((a, b) => {
+      const aIsGeneral = a.methodRegex.source === ".*";
+      const bIsGeneral = b.methodRegex.source === ".*";
+      if (aIsGeneral && !bIsGeneral) return 1;
+      if (!aIsGeneral && bIsGeneral) return -1;
+      return 0;
+    });
+    if (matchingRules.length === 0) {
+      return true;
+    }
+    for (const rule of matchingRules) {
+      if (rule.excludeRegex && rule.excludeRegex.test(targetName)) {
+        return false;
+      }
+      if (rule.applyRegex) {
+        return rule.applyRegex.test(targetName);
+      }
+    }
+    return true;
+  }
+  isExcluded(ctor, method) {
+    const componentCtor = typeof ctor === "function" ? ctor : ctor.constructor;
+    return new A_ManifestChecker(this, componentCtor, method, true);
+  }
+};
+A_Manifest = __decorateClass([
+  A_Frame.Fragment({
+    namespace: "A-Utils",
+    name: "A-Manifest",
+    description: "A-Manifest is a configuration fragment that allows to include or exclude component application for particular methods. It provides fine-grained control over which components are applied to which targets and methods within the application, enabling flexible and dynamic behavior based on defined rules."
+  })
+], A_Manifest);
+
+export { A_Manifest };
+//# sourceMappingURL=A-Manifest.context.mjs.map
+//# sourceMappingURL=A-Manifest.context.mjs.map